feat: surface hook lifecycle events

Author: Dimillian

docs/app-server-events.md

@@ -62,6 +62,8 @@ subscriptions.
 - `account/updated`
 - `app/list/updated`
 - `error`
+- `hook/completed`
+- `hook/started`
 - `item/agentMessage/delta`
 - `item/commandExecution/outputDelta`
 - `item/commandExecution/terminalInteraction`
@@ -123,8 +125,6 @@ events are currently not routed:
 - `deprecationNotice`
 - `fuzzyFileSearch/sessionCompleted`
 - `fuzzyFileSearch/sessionUpdated`
-- `hook/completed`
-- `hook/started`
 - `item/mcpToolCall/progress`
 - `mcpServer/oauthLogin/completed`
 - `model/rerouted`

src-tauri/src/backend/app_server.rs

@@ -1125,6 +1125,18 @@ mod tests {
         assert_eq!(extract_thread_id(&value), Some("thread-456".to_string()));
     }
 
+    #[test]
+    fn extract_thread_id_reads_hook_notification_thread_id() {
+        let value = json!({
+            "method": "hook/started",
+            "params": {
+                "threadId": "thread-hook-1",
+                "run": { "id": "hook-1" }
+            }
+        });
+        assert_eq!(extract_thread_id(&value), Some("thread-hook-1".to_string()));
+    }
+
     #[test]
     fn extract_thread_id_returns_none_when_missing() {
         let value = json!({ "params": {} });

src/features/app/hooks/useAppServerEvents.test.tsx

@@ -47,6 +47,8 @@ describe("useAppServerEvents", () => {
     const handlers: Handlers = {
       onAppServerEvent: vi.fn(),
       onWorkspaceConnected: vi.fn(),
+      onHookStarted: vi.fn(),
+      onHookCompleted: vi.fn(),
       onThreadStarted: vi.fn(),
       onThreadNameUpdated: vi.fn(),
       onThreadStatusChanged: vi.fn(),
@@ -121,6 +123,45 @@ describe("useAppServerEvents", () => {
       "- Step 1",
     );
 
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "hook/started",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            run: { id: "hook-1", eventName: "session-start", statusMessage: "Preparing" },
+          },
+        },
+      });
+    });
+    expect(handlers.onHookStarted).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      turnId: "turn-1",
+      run: { id: "hook-1", eventName: "session-start", statusMessage: "Preparing" },
+    });
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "hook/completed",
+          params: {
+            threadId: "thread-1",
+            run: { id: "hook-1", eventName: "session-start", status: "completed" },
+          },
+        },
+      });
+    });
+    expect(handlers.onHookCompleted).toHaveBeenCalledWith({
+      workspaceId: "ws-1",
+      threadId: "thread-1",
+      turnId: null,
+      run: { id: "hook-1", eventName: "session-start", status: "completed" },
+    });
+
     act(() => {
       listener?.({
         workspace_id: "ws-1",

src/features/app/hooks/useAppServerEvents.ts

@@ -28,6 +28,13 @@ type AgentCompleted = {
   text: string;
 };
 
+type HookEvent = {
+  workspaceId: string;
+  threadId: string;
+  turnId: string | null;
+  run: Record<string, unknown>;
+};
+
 type AppServerEventHandlers = {
   onWorkspaceConnected?: (workspaceId: string) => void;
   onThreadStarted?: (workspaceId: string, thread: Record<string, unknown>) => void;
@@ -67,6 +74,8 @@ type AppServerEventHandlers = {
     turnId: string,
     payload: { explanation: unknown; plan: unknown },
   ) => void;
+  onHookStarted?: (event: HookEvent) => void;
+  onHookCompleted?: (event: HookEvent) => void;
   onItemStarted?: (workspaceId: string, threadId: string, item: Record<string, unknown>) => void;
   onItemCompleted?: (workspaceId: string, threadId: string, item: Record<string, unknown>) => void;
   onReasoningSummaryDelta?: (workspaceId: string, threadId: string, itemId: string, delta: string) => void;
@@ -105,6 +114,8 @@ export const METHODS_ROUTED_IN_USE_APP_SERVER_EVENTS = [
   "codex/backgroundThread",
   "codex/connected",
   "error",
+  "hook/completed",
+  "hook/started",
   "item/agentMessage/delta",
   "item/commandExecution/outputDelta",
   "item/commandExecution/terminalInteraction",
@@ -129,6 +140,31 @@ export const METHODS_ROUTED_IN_USE_APP_SERVER_EVENTS = [
   "turn/started",
 ] as const satisfies readonly SupportedAppServerMethod[];
 
+function parseHookEvent(
+  workspaceId: string,
+  params: Record<string, unknown>,
+): HookEvent | null {
+  const threadId = String(params.threadId ?? params.thread_id ?? "").trim();
+  if (!threadId) {
+    return null;
+  }
+  const run = params.run;
+  if (!run || typeof run !== "object" || Array.isArray(run)) {
+    return null;
+  }
+  const turnIdRaw = params.turnId ?? params.turn_id ?? null;
+  const turnId =
+    typeof turnIdRaw === "string" && turnIdRaw.trim().length > 0
+      ? turnIdRaw.trim()
+      : null;
+  return {
+    workspaceId,
+    threadId,
+    turnId,
+    run: run as Record<string, unknown>,
+  };
+}
+
 export function useAppServerEvents(handlers: AppServerEventHandlers) {
   // Use ref to keep handlers current without triggering re-subscription
   const handlersRef = useRef(handlers);
@@ -238,6 +274,22 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
         return;
       }
 
+      if (method === "hook/started") {
+        const event = parseHookEvent(workspace_id, params);
+        if (event) {
+          currentHandlers.onHookStarted?.(event);
+        }
+        return;
+      }
+
+      if (method === "hook/completed") {
+        const event = parseHookEvent(workspace_id, params);
+        if (event) {
+          currentHandlers.onHookCompleted?.(event);
+        }
+        return;
+      }
+
       if (method === "thread/started") {
         const thread = (params.thread as Record<string, unknown> | undefined) ?? null;
         const threadId = String(thread?.id ?? "");

src/features/messages/components/MessageRows.tsx

@@ -24,6 +24,7 @@ import {
   buildToolSummary,
   exploreKindLabel,
   formatDurationMs,
+  formatToolStatusLabel,
   normalizeMessageImageSrc,
   toolNameFromTitle,
   toolStatusTone,
@@ -703,6 +704,7 @@ export const ToolRow = memo(function ToolRow({
     : isCommand
       ? ""
       : summary.label;
+  const inlineStatus = formatToolStatusLabel(item);
   const summaryValue = isFileChange
     ? changeNames.length > 1
       ? `${changeNames[0]} +${changeNames.length - 1}`
@@ -806,6 +808,9 @@ export const ToolRow = memo(function ToolRow({
               )}
             </span>
           )}
+          {inlineStatus && (
+            <span className="tool-inline-status">{inlineStatus}</span>
+          )}
         </button>
         {isExpanded && summary.detail && !isFileChange && (
           <div className="tool-inline-detail">{summary.detail}</div>

src/features/messages/components/Messages.test.tsx

@@ -1589,4 +1589,40 @@ describe("Messages", () => {
     expect(screen.getByText("Input requested")).toBeTruthy();
     expect(screen.queryByText("Plan ready")).toBeNull();
   });
+
+  it("renders hook rows through the standard tool renderer", () => {
+    const items: ConversationItem[] = [
+      {
+        id: "hook-hook-1",
+        kind: "tool",
+        toolType: "hook",
+        title: "Hook: session-start",
+        detail: "command • sync • thread • session-start.sh • Preparing",
+        status: "failed",
+        output: "[error] Missing config",
+        durationMs: 3100,
+      },
+    ];
+
+    render(
+      <Messages
+        items={items}
+        threadId="thread-1"
+        workspaceId="ws-1"
+        isThinking={false}
+        openTargets={[]}
+        selectedOpenAppId=""
+      />,
+    );
+
+    expect(screen.getByText("hook:")).toBeTruthy();
+    expect(screen.getByText("session-start")).toBeTruthy();
+    expect(screen.getByText("failed • 0:03")).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: "Toggle tool details" }));
+    expect(
+      screen.getByText("command • sync • thread • session-start.sh • Preparing"),
+    ).toBeTruthy();
+    expect(screen.getByText("[error] Missing config")).toBeTruthy();
+  });
 });

src/features/messages/utils/messageRenderUtils.ts

@@ -365,6 +365,15 @@ export function buildToolSummary(
     };
   }
 
+  if (item.toolType === "hook") {
+    return {
+      label: "hook",
+      value: item.title.replace(/^Hook:\s*/i, "").trim() || item.title || "hook",
+      detail: item.detail || "",
+      output: item.output || "",
+    };
+  }
+
   if (item.toolType === "collabToolCall") {
     return {
       label: summarizeCollabLabel(item.title, item.status),
@@ -448,6 +457,23 @@ export function toolStatusTone(
   return "processing";
 }
 
+export function formatToolStatusLabel(
+  item: Extract<ConversationItem, { kind: "tool" }>,
+) {
+  if (item.toolType !== "hook") {
+    return "";
+  }
+  const parts: string[] = [];
+  const status = (item.status ?? "").trim().toLowerCase();
+  if (status) {
+    parts.push(status.replace(/[_-]+/g, " "));
+  }
+  if (typeof item.durationMs === "number" && Number.isFinite(item.durationMs)) {
+    parts.push(formatDurationMs(item.durationMs));
+  }
+  return parts.join(" • ");
+}
+
 
 export type PlanFollowupState = {
   shouldShow: boolean;

src/features/threads/hooks/useThreadEventHandlers.ts

@@ -1,8 +1,15 @@
 import { useCallback, useMemo } from "react";
 import type { Dispatch, MutableRefObject } from "react";
-import type { AppServerEvent, DebugEntry, RateLimitSnapshot, TurnPlan } from "@/types";
+import type {
+  AppServerEvent,
+  ConversationItem,
+  DebugEntry,
+  RateLimitSnapshot,
+  TurnPlan,
+} from "@/types";
 import { getAppServerRawMethod } from "@utils/appServerEvents";
 import { useThreadApprovalEvents } from "./useThreadApprovalEvents";
+import { useThreadHookEvents } from "./useThreadHookEvents";
 import { useThreadItemEvents } from "./useThreadItemEvents";
 import { useThreadTurnEvents } from "./useThreadTurnEvents";
 import { useThreadUserInputEvents } from "./useThreadUserInputEvents";
@@ -11,6 +18,7 @@ import type { ThreadAction } from "./useThreadsReducer";
 type ThreadEventHandlersOptions = {
   activeThreadId: string | null;
   dispatch: Dispatch<ThreadAction>;
+  getItemsForThread: (threadId: string) => ConversationItem[];
   planByThreadRef: MutableRefObject<Record<string, TurnPlan | null>>;
   getCurrentRateLimits?: (workspaceId: string) => RateLimitSnapshot | null;
   getCustomName: (workspaceId: string, threadId: string) => string | undefined;
@@ -47,6 +55,7 @@ type ThreadEventHandlersOptions = {
 export function useThreadEventHandlers({
   activeThreadId,
   dispatch,
+  getItemsForThread,
   planByThreadRef,
   getCurrentRateLimits,
   getCustomName,
@@ -72,6 +81,46 @@ export function useThreadEventHandlers({
     approvalAllowlistRef,
   });
   const onRequestUserInput = useThreadUserInputEvents({ dispatch });
+  const {
+    onHookStarted: handleHookStarted,
+    onHookCompleted: handleHookCompleted,
+  } = useThreadHookEvents({
+    dispatch,
+    getItemsForThread,
+    safeMessageActivity,
+  });
+  const onHookStarted = useCallback(
+    ({
+      workspaceId,
+      threadId,
+      turnId,
+      run,
+    }: {
+      workspaceId: string;
+      threadId: string;
+      turnId: string | null;
+      run: Record<string, unknown>;
+    }) => {
+      handleHookStarted(workspaceId, threadId, turnId, run);
+    },
+    [handleHookStarted],
+  );
+  const onHookCompleted = useCallback(
+    ({
+      workspaceId,
+      threadId,
+      turnId,
+      run,
+    }: {
+      workspaceId: string;
+      threadId: string;
+      turnId: string | null;
+      run: Record<string, unknown>;
+    }) => {
+      handleHookCompleted(workspaceId, threadId, turnId, run);
+    },
+    [handleHookCompleted],
+  );
 
   const {
     onAgentMessageDelta,
@@ -159,6 +208,8 @@ export function useThreadEventHandlers({
       onWorkspaceConnected,
       onApprovalRequest,
       onRequestUserInput,
+      onHookStarted,
+      onHookCompleted,
       onBackgroundThreadAction,
       onAppServerEvent,
       onAgentMessageDelta,
@@ -190,6 +241,8 @@ export function useThreadEventHandlers({
       onWorkspaceConnected,
       onApprovalRequest,
       onRequestUserInput,
+      onHookStarted,
+      onHookCompleted,
       onBackgroundThreadAction,
       onAppServerEvent,
       onAgentMessageDelta,