@botcord/daemon 0.2.13 → 0.2.15

package/src/gateway/channels/botcord.ts

@@ -15,6 +15,7 @@ import type {
   ChannelStatusSnapshot,
   ChannelStopContext,
   ChannelStreamBlockContext,
+  ChannelTypingContext,
   GatewayInboundEnvelope,
   GatewayInboundMessage,
   GatewayLogger,
@@ -690,6 +691,32 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       }
     },
 
+    async typing(ctx: ChannelTypingContext): Promise<void> {
+      const client = ensureClient();
+      const hubUrl = options.hubBaseUrl ?? client.getHubUrl();
+      try {
+        const token = await client.ensureToken();
+        const resp = await fetch(`${hubUrl}/hub/typing`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({ room_id: ctx.conversationId }),
+          signal: AbortSignal.timeout(10_000),
+        });
+        if (!resp.ok && resp.status !== 204) {
+          const body = await resp.text().catch(() => "");
+          ctx.log.warn("botcord typing non-ok", {
+            status: resp.status,
+            body: body.slice(0, 200),
+          });
+        }
+      } catch (err) {
+        ctx.log.warn("botcord typing failed", { err: String(err) });
+      }
+    },
+
     status(): ChannelStatusSnapshot {
       return { ...statusSnapshot };
     },
@@ -777,6 +804,17 @@ function normalizeBlockForHub(
     return { kind: "system", seq, payload };
   }
 
+  if (kind === "thinking") {
+    // Daemon-synthesized lifecycle marker. `raw` carries `{ phase, label?, source? }`
+    // — see Dispatcher's status forwarding. The frontend uses `phase` to decide
+    // whether to enter/leave the compact "Thinking..." UI; `label` is a free-form
+    // human hint (e.g. "Searching web"). Treat as untrusted text — never inject.
+    if (typeof raw?.phase === "string") payload.phase = raw.phase;
+    if (typeof raw?.label === "string") payload.label = raw.label;
+    if (typeof raw?.source === "string") payload.source = raw.source;
+    return { kind: "thinking", seq, payload };
+  }
+
   // "other" — e.g. Claude Code `type:"result"` end-of-turn summary.
   if (raw?.type === "result") {
     if (typeof raw.result === "string") payload.text = raw.result;

package/src/gateway/dispatcher.ts

@@ -21,6 +21,7 @@ import type {
   OutboundObserver,
   QueueMode,
   RuntimeAdapter,
+  RuntimeStatusEvent,
   StreamBlock,
   SystemContextBuilder,
   TurnStatusSnapshot,
@@ -47,6 +48,16 @@ const MAX_BATCH_BUFFER_ENTRIES = 40;
  */
 const MAX_BATCH_BUFFER_CHARS = 16000;
 
+/**
+ * Per-(accountId, conversationId) cooldown between successive `/hub/typing`
+ * pings. Hub rate-limits to 20 typing/min per agent (backend hub.py:1675);
+ * cancel-previous bursts on a fast user can otherwise trip 429 silently.
+ */
+const TYPING_DEBOUNCE_MS = 2000;
+
+/** LRU cap on the typing-recency map so long-running daemons don't grow unbounded. */
+const TYPING_RECENCY_CAP = 1024;
+
 /** Factory signature for building a runtime adapter at turn dispatch time. */
 export type RuntimeFactory = (
   runtimeId: string,
@@ -214,6 +225,12 @@ export class Dispatcher {
   private readonly resolveHubUrl?: (accountId: string) => string | undefined;
   private readonly transcript: TranscriptWriter;
   private readonly queues: Map<string, QueueState> = new Map();
+  /**
+   * Last `/hub/typing` ping timestamp per (accountId, conversationId).
+   * Used to debounce cancel-previous bursts so we don't trip Hub's 20/min
+   * rate limit. True LRU (delete + set on access) capped at TYPING_RECENCY_CAP.
+   */
+  private readonly recentTypingPings: Map<string, number> = new Map();
 
   constructor(opts: DispatcherOptions) {
     this.config = opts.config;
@@ -757,27 +774,206 @@ export class Dispatcher {
       }
       slot.blocks.push(summary);
     };
-    const onBlock = canStream
+
+    // Owner-chat lifecycle state for typing/thinking. The dispatcher is the
+    // only component that sees turn boundaries + channel capabilities + trace
+    // ids together, so it owns the收束: once `typing.started` fires we never
+    // re-fire it within this turn (frontend clears via stream/message
+    // arrival), and `thinking` is auto-synthesized on the first non-assistant
+    // block so adapters that emit nothing-but-blocks still drive the
+    // "Thinking..." UI.
+    let typingFired = false;
+    let thinkingActive = false;
+    /**
+     * Sticky: once we've forwarded any assistant_text to the wire, we stop
+     * auto-synthesizing thinking on plain `system`/`other` blocks. This
+     * prevents the post-prose flicker caused by Codex's `turn.completed` /
+     * Claude Code's `result` (both arrive as system/other AFTER the prose).
+     * `tool_use` is the explicit exception — agents that legitimately go
+     * back to work after a partial answer should still drive "Thinking…".
+     */
+    let sawAssistantText = false;
+    let blocksSent = 0;
+
+    const forwardBlockToChannel = canStream
       ? (block: StreamBlock) => {
-          recordBlock(block);
-          // Fire-and-forget: stream errors must not break the turn.
-          channel
-            .streamBlock!({
-              traceId: traceId!,
-              accountId: msg.accountId,
-              conversationId: msg.conversation.id,
-              block,
-              log: this.log,
-            })
-            .catch((err) => {
-              this.log.warn("dispatcher: streamBlock failed", {
-                traceId,
-                error: err instanceof Error ? err.message : String(err),
+          // Re-sequence at the wire boundary so synthesized thinking blocks
+          // interleave cleanly with adapter-emitted blocks; adapters keep
+          // their own per-turn seq for tracing/logging only.
+          blocksSent += 1;
+          const ctx = {
+            traceId: traceId!,
+            accountId: msg.accountId,
+            conversationId: msg.conversation.id,
+            block: { ...block, seq: blocksSent },
+            log: this.log,
+          };
+          // Coerce a synchronous throw from a non-async adapter into the same
+          // warn path as an async rejection so a buggy channel never tears
+          // down the turn (the adapter contract is fire-and-forget).
+          try {
+            const ret = channel.streamBlock!(ctx);
+            if (ret && typeof (ret as Promise<void>).catch === "function") {
+              (ret as Promise<void>).catch((err) => {
+                this.log.warn("dispatcher: streamBlock failed", {
+                  traceId,
+                  error: err instanceof Error ? err.message : String(err),
+                });
               });
+            }
+          } catch (err) {
+            this.log.warn("dispatcher: streamBlock threw", {
+              traceId,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        }
+      : undefined;
+
+    const sendThinkingMarker = (
+      phase: "started" | "updated" | "stopped",
+      label: string | undefined,
+      source: "dispatcher" | "runtime",
+    ): void => {
+      if (!forwardBlockToChannel) return;
+      const raw: Record<string, unknown> = { phase, source };
+      if (label) raw.label = label;
+      const synth: StreamBlock = { raw, kind: "thinking", seq: 0 };
+      // Intentionally NOT `recordBlock(synth)` — the transcript stays
+      // adapter-truth so downstream log consumers see only what the runtime
+      // actually emitted, not daemon-synthesized lifecycle frames.
+      forwardBlockToChannel(synth);
+    };
+
+    const fireTypingIfNeeded = (): void => {
+      if (!canStream || typingFired || typeof channel.typing !== "function") return;
+      typingFired = true;
+      const key = `${msg.accountId}:${msg.conversation.id}`;
+      const now = Date.now();
+      const last = this.recentTypingPings.get(key);
+      if (last !== undefined && now - last < TYPING_DEBOUNCE_MS) {
+        // Within the debounce window — Hub's 2s dedup absorbs this. The
+        // window thins out cancel-previous bursts; it does NOT fully
+        // prevent 429s when many active rooms ping concurrently, so the
+        // try/catch around `channel.typing()` is what actually keeps the
+        // turn alive on rate-limit (backend hub.py:1675).
+        return;
+      }
+      // True LRU: delete-then-set bumps the entry to the tail of the Map
+      // insertion order, so chronically active conversations never get
+      // evicted by an unrelated newcomer at the cap.
+      this.recentTypingPings.delete(key);
+      this.recentTypingPings.set(key, now);
+      if (this.recentTypingPings.size > TYPING_RECENCY_CAP) {
+        const oldest = this.recentTypingPings.keys().next().value;
+        if (oldest !== undefined) this.recentTypingPings.delete(oldest);
+      }
+      const ctx = {
+        traceId: traceId!,
+        accountId: msg.accountId,
+        conversationId: msg.conversation.id,
+        log: this.log,
+      };
+      try {
+        const ret = channel.typing!(ctx);
+        if (ret && typeof (ret as Promise<void>).catch === "function") {
+          (ret as Promise<void>).catch((err) => {
+            this.log.warn("dispatcher: channel.typing failed", {
+              traceId,
+              error: err instanceof Error ? err.message : String(err),
             });
+          });
+        }
+      } catch (err) {
+        this.log.warn("dispatcher: channel.typing threw", {
+          traceId,
+          error: err instanceof Error ? err.message : String(err),
+        });
+      }
+    };
+
+    const onStatus = canStream
+      ? (event: RuntimeStatusEvent) => {
+          // Drop runtime callbacks after this turn's controller aborts —
+          // NDJSON/ACP adapters keep parsing stdout until the child exits
+          // (up to KILL_GRACE_MS after SIGTERM), so without this guard a
+          // superseded turn leaks frames to the new turn's UI.
+          if (controller.signal.aborted) return;
+          if (event.kind === "typing") {
+            // `/hub/typing` has no stopped semantic — frontend self-clears on
+            // stream/message arrival. typing.stopped is observed for daemon
+            // bookkeeping only (currently a no-op; kept for telemetry).
+            if (event.phase === "started") fireTypingIfNeeded();
+            return;
+          }
+          if (event.phase === "stopped") {
+            // Forward to wire ONLY if we previously announced thinking — that
+            // way `finalizeThinkingIfActive` doesn't double-emit, and adapters
+            // that signal terminal closure earlier than child exit (e.g.
+            // acp-stream's prompt-done) reach the frontend without waiting.
+            if (thinkingActive) {
+              sendThinkingMarker("stopped", event.label, "runtime");
+            }
+            thinkingActive = false;
+            return;
+          }
+          // Runtime-emitted thinking.started/.updated is trusted unconditionally:
+          // we deliberately do NOT apply the `sawAssistantText` sticky guard
+          // here, only to dispatcher-synthesized starts. Adapters opting into
+          // explicit status events accept the responsibility of driving a
+          // sensible lifecycle (don't fire .started after the final answer).
+          thinkingActive = true;
+          sendThinkingMarker(event.phase, event.label, "runtime");
         }
       : undefined;
 
+    const onBlock = canStream
+      ? (block: StreamBlock) => {
+          // Always record adapter-emitted blocks for transcript fidelity, even
+          // after abort — the transcript reflects what the runtime emitted,
+          // not what the dispatcher chose to forward.
+          recordBlock(block);
+          if (controller.signal.aborted) return;
+          // Synthesize thinking.started before non-assistant blocks. After
+          // we've seen any assistant_text, only `tool_use` may re-enter
+          // thinking — terminal markers like `system`/`other` (codex
+          // `turn.completed`, claude `result`) would otherwise flicker
+          // "Thinking…" right after the final answer.
+          if (!thinkingActive && block.kind !== "assistant_text") {
+            const allowed = !sawAssistantText || block.kind === "tool_use";
+            if (allowed) {
+              thinkingActive = true;
+              sendThinkingMarker("started", undefined, "dispatcher");
+            }
+          }
+          // Once assistant prose lands, the user is reading the answer — exit
+          // thinking. Frontend hides "Thinking..." once any assistant_text
+          // block has flushed; we just keep our internal flag aligned.
+          if (block.kind === "assistant_text") {
+            thinkingActive = false;
+            sawAssistantText = true;
+          }
+          forwardBlockToChannel!(block);
+        }
+      : undefined;
+
+    // Helper used by terminal paths (success / timeout / error) to ensure
+    // the frontend doesn't get stuck in "Thinking..." when no assistant_text
+    // ever lands. Skips on cancel-previous because the superseder will run
+    // its own typing/thinking sequence.
+    const finalizeThinkingIfActive = (): void => {
+      if (!canStream || !thinkingActive) return;
+      const supersededByCancel = controller.signal.aborted && !slot.timedOut;
+      if (supersededByCancel) return;
+      thinkingActive = false;
+      sendThinkingMarker("stopped", undefined, "dispatcher");
+    };
+
+    // Eagerly fire typing.started before runtime.run so the user sees
+    // "agent is responding" within ~one round-trip even if the runtime takes
+    // seconds before its first block.
+    fireTypingIfNeeded();
+
     // Compute systemContext right before dispatch. The builder must NOT block
     // the turn on failure — log and continue so a flaky memory read can't
     // silence the agent.
@@ -812,6 +1008,7 @@ export class Dispatcher {
           trustLevel,
           systemContext,
           onBlock,
+          onStatus,
           gateway: route.gateway,
         });
       } catch (err) {
@@ -1053,6 +1250,11 @@ export class Dispatcher {
         blocks: slot.blocks,
       });
     } finally {
+      // Emit a final thinking.stopped on terminal paths so the frontend
+      // never sticks at "Thinking..." when no assistant_text ever landed
+      // (timeout, error, gated reply). Skipped on cancel-previous: the
+      // superseder is about to run its own typing/thinking lifecycle.
+      finalizeThinkingIfActive();
       // Clear slot ownership AFTER the reply has been sent (or skipped).
       // Only then do cancel-previous arrivals stop finding this slot — which
       // is exactly what we want: while we're in the post-runtime window, a

package/src/gateway/runtimes/acp-stream.ts

@@ -5,6 +5,7 @@ import type {
   RuntimeProbeResult,
   RuntimeRunOptions,
   RuntimeRunResult,
+  RuntimeStatusEvent,
   StreamBlock,
 } from "../types.js";
 
@@ -85,6 +86,12 @@ export interface AcpUpdateCtx {
   appendAssistantText(text: string): void;
   /** Forward a normalized StreamBlock to `opts.onBlock`. */
   emitBlock(block: StreamBlock): void;
+  /**
+   * Forward a runtime status event (typing / thinking) to the dispatcher.
+   * Useful for ACP `session/update` shapes that signal "agent is busy" but
+   * carry no displayable content (e.g. thought chunks, tool progress).
+   */
+  emitStatus(event: RuntimeStatusEvent): void;
   /** 1-based sequence within this turn. */
   seq: number;
 }
@@ -381,6 +388,13 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
             this.onUpdate(params as AcpUpdateParams, {
               appendAssistantText,
               emitBlock: (b) => opts.onBlock?.(b),
+              emitStatus: (e) => {
+                try {
+                  opts.onStatus?.(e);
+                } catch (err) {
+                  log.warn(`${this.id} onStatus threw`, { err: String(err) });
+                }
+              },
               seq,
             });
           }
@@ -466,6 +480,16 @@ export abstract class AcpRuntimeAdapter implements RuntimeAdapter {
       if (stopReason === "refusal" || stopReason === "error") {
         state.errorText = state.errorText ?? `prompt stopped: ${stopReason}`;
       }
+      // Tell the dispatcher the runtime has finished its reasoning loop —
+      // important for turns that ended without an `agent_message_chunk`
+      // (tool-only side effect, refusal, error). The dispatcher's finally
+      // block also emits a final thinking.stopped, but firing here delivers
+      // it on the wire before child exit (which can take seconds).
+      try {
+        opts.onStatus?.({ kind: "thinking", phase: "stopped" });
+      } catch (err) {
+        log.warn(`${this.id} onStatus(prompt-done) threw`, { err: String(err) });
+      }
 
       // Politely close stdin so the server can exit. Some ACP servers shut
       // down on EOF; if not, abort signal will SIGTERM.

package/src/gateway/runtimes/claude-code.ts

@@ -140,9 +140,14 @@ export class ClaudeCodeAdapter extends NdjsonStreamAdapter {
       session_id?: string;
       total_cost_usd?: number;
       result?: string;
-      message?: { content?: Array<{ type?: string; text?: string }> };
+      message?: { content?: Array<{ type?: string; text?: string; name?: string }> };
     };
 
+    // Emit a thinking lifecycle hint BEFORE the block so the dispatcher's
+    // auto-synthesis short-circuits (we provide a labeled event instead).
+    const status = claudeStatusEvent(obj);
+    if (status) ctx.emitStatus(status);
+
     ctx.emitBlock(normalizeBlock(obj, ctx.seq));
 
     if (obj.type === "system" && obj.session_id) {
@@ -176,6 +181,41 @@ export class ClaudeCodeAdapter extends NdjsonStreamAdapter {
   }
 }
 
+/**
+ * Map a Claude Code stream-json event to a `RuntimeStatusEvent`. We only
+ * return events for transitions the dispatcher cannot infer from block kinds
+ * alone — the auto-synthesis path covers the unlabeled case.
+ *
+ * Note: Claude Code's `assistant` events sometimes mix `text` and `tool_use`
+ * blocks. When `text` is present we treat it as "thinking stopped"; when
+ * `tool_use` is present without `text` we surface the tool name as a label.
+ */
+function claudeStatusEvent(obj: {
+  type?: string;
+  subtype?: string;
+  message?: { content?: Array<{ type?: string; text?: string; name?: string }> };
+}): import("../types.js").RuntimeStatusEvent | undefined {
+  if (obj.type === "system" && obj.subtype === "init") {
+    return { kind: "thinking", phase: "started", label: "Starting session" };
+  }
+  if (obj.type === "assistant" && Array.isArray(obj.message?.content)) {
+    const contents = obj.message.content;
+    const hasText = contents.some(
+      (c) => c?.type === "text" && typeof c.text === "string" && c.text.length > 0,
+    );
+    if (hasText) return { kind: "thinking", phase: "stopped" };
+    const tool = contents.find((c) => c?.type === "tool_use");
+    if (tool) {
+      const name = typeof tool.name === "string" && tool.name ? tool.name : "tool";
+      return { kind: "thinking", phase: "updated", label: name };
+    }
+  }
+  if (obj.type === "result") {
+    return { kind: "thinking", phase: "stopped" };
+  }
+  return undefined;
+}
+
 function normalizeBlock(obj: any, seq: number): StreamBlock {
   let kind: StreamBlock["kind"] = "other";
   if (obj?.type === "assistant") {

package/src/gateway/runtimes/codex.ts

@@ -242,6 +242,12 @@ export class CodexAdapter extends NdjsonStreamAdapter {
       turn?: { status?: string; error?: { message?: string } };
     };
 
+    // Emit a thinking lifecycle hint BEFORE the block so the dispatcher's
+    // auto-synthesis short-circuits (we provide a labeled event instead).
+    // Conservative mapping per design doc §"Runtime adapter 映射".
+    const status = codexStatusEvent(obj);
+    if (status) ctx.emitStatus(status);
+
     ctx.emitBlock(normalizeBlock(obj, ctx.seq));
 
     // Persist the thread_id so the next turn on this session key resumes
@@ -278,6 +284,58 @@ export class CodexAdapter extends NdjsonStreamAdapter {
   }
 }
 
+/**
+ * Map a Codex JSONL event to a `RuntimeStatusEvent` for the dispatcher's
+ * thinking UI. Returns `undefined` for events that should not influence
+ * status (the dispatcher already synthesizes a generic marker on the first
+ * non-assistant block, so we only override when a label is meaningful).
+ */
+function codexStatusEvent(obj: {
+  type?: string;
+  item?: { type?: string };
+  turn?: { status?: string };
+}): import("../types.js").RuntimeStatusEvent | undefined {
+  if (obj.type === "thread.started") {
+    return { kind: "thinking", phase: "started", label: "Starting session" };
+  }
+  if (obj.type === "turn.started") {
+    return { kind: "thinking", phase: "started", label: "Thinking" };
+  }
+  if (obj.type === "item.started" && typeof obj.item?.type === "string") {
+    const tool = obj.item.type;
+    if (
+      tool === "command_execution" ||
+      tool === "file_change" ||
+      tool === "mcp_tool_call" ||
+      tool === "web_search"
+    ) {
+      return { kind: "thinking", phase: "updated", label: codexToolLabel(tool) };
+    }
+  }
+  if (obj.type === "item.completed" && obj.item?.type === "agent_message") {
+    return { kind: "thinking", phase: "stopped" };
+  }
+  if (obj.type === "turn.completed") {
+    return { kind: "thinking", phase: "stopped" };
+  }
+  return undefined;
+}
+
+function codexToolLabel(tool: string): string {
+  switch (tool) {
+    case "command_execution":
+      return "Running command";
+    case "file_change":
+      return "Editing files";
+    case "mcp_tool_call":
+      return "Calling tool";
+    case "web_search":
+      return "Searching web";
+    default:
+      return tool;
+  }
+}
+
 /**
  * Atomically overwrite `<CODEX_HOME>/AGENTS.md` with `systemContext`. codex
  * reads this file at process start, so the write must complete before spawn.

package/src/gateway/runtimes/hermes-agent.ts

@@ -181,32 +181,47 @@ export class HermesAgentAdapter extends AcpRuntimeAdapter {
    * assistant text. We surface the common shapes that hermes emits:
    *   - `agent_message_chunk` / `user_message_chunk` content blocks
    *   - `tool_call` / `tool_call_update`
-   *   - `agent_thought_chunk`
+   *   - `agent_thought_chunk` (status-only — see below)
    *
-   * Anything else is forwarded as `kind: "other"` so subclasses /
-   * downstream channels can introspect.
+   * `agent_thought_chunk` deliberately maps to ONLY a `thinking.updated`
+   * status event, NOT a block: the underlying ACP payload has no `subtype`
+   * / `session_id` / `model` fields that `normalizeBlockForHub("system")`
+   * would render, so emitting a `kind:"system"` block here just produces an
+   * empty payload alongside the labeled thinking frame. Anything else is
+   * forwarded as `kind: "other"` so subclasses / downstream channels can
+   * introspect.
    */
   protected onUpdate(params: AcpUpdateParams, ctx: AcpUpdateCtx): void {
     const update = params.update ?? {};
     const kind = typeof update.sessionUpdate === "string" ? update.sessionUpdate : "";
 
+    if (kind === "agent_thought_chunk") {
+      ctx.emitStatus({ kind: "thinking", phase: "updated", label: "Thinking" });
+      return;
+    }
+
     let blockKind: StreamBlock["kind"] = "other";
+    let assistantTextSeen = false;
 
     if (kind === "agent_message_chunk") {
       const content = (update as { content?: { type?: string; text?: string } })
         .content;
       if (content && content.type === "text" && typeof content.text === "string") {
         ctx.appendAssistantText(content.text);
+        assistantTextSeen = content.text.length > 0;
       }
       blockKind = "assistant_text";
-    } else if (kind === "agent_thought_chunk") {
-      blockKind = "system";
     } else if (kind === "tool_call" || kind === "tool_call_update") {
       blockKind = "tool_use";
     } else if (kind === "user_message_chunk") {
       blockKind = "other";
     }
 
+    // Status hint BEFORE the block so the dispatcher's auto-synthesis sees a
+    // labeled `thinking.updated`/`stopped` instead of a bare `started`.
+    const status = hermesStatusEvent(kind, update, assistantTextSeen);
+    if (status) ctx.emitStatus(status);
+
     ctx.emitBlock({ raw: params, kind: blockKind, seq: ctx.seq });
   }
 
@@ -237,3 +252,28 @@ export class HermesAgentAdapter extends AcpRuntimeAdapter {
     return { outcome: { outcome: "cancelled" } };
   }
 }
+
+/**
+ * Map an ACP `session/update` payload to a `RuntimeStatusEvent`. We only
+ * return events that add a label or convey a transition the dispatcher
+ * cannot infer from block kinds — the auto-synthesis path covers the rest.
+ */
+function hermesStatusEvent(
+  kind: string,
+  update: { content?: { type?: string; text?: string }; toolCall?: { name?: string } } & Record<
+    string,
+    unknown
+  >,
+  assistantTextSeen: boolean,
+): import("../types.js").RuntimeStatusEvent | undefined {
+  // `agent_thought_chunk` is handled inline in `onUpdate` (status-only path).
+  if (kind === "tool_call" || kind === "tool_call_update") {
+    const tool = (update as { toolCall?: { name?: string } }).toolCall;
+    const name = typeof tool?.name === "string" && tool.name ? tool.name : "tool";
+    return { kind: "thinking", phase: "updated", label: name };
+  }
+  if (kind === "agent_message_chunk" && assistantTextSeen) {
+    return { kind: "thinking", phase: "stopped" };
+  }
+  return undefined;
+}

package/src/gateway/runtimes/ndjson-stream.ts

@@ -6,6 +6,7 @@ import type {
   RuntimeProbeResult,
   RuntimeRunOptions,
   RuntimeRunResult,
+  RuntimeStatusEvent,
   StreamBlock,
 } from "../types.js";
 
@@ -40,6 +41,13 @@ export interface NdjsonEventCtx {
    * Subclasses should use this instead of `state.assistantTextChunks.push(...)`.
    */
   appendAssistantText: (text: string) => void;
+  /**
+   * Forward a runtime status event (typing / thinking) to the dispatcher.
+   * Adapters should call this when an event reveals the runtime's lifecycle
+   * stage before any visible block lands — e.g. Codex `thread.started`,
+   * Claude Code `system` init. Errors thrown here are swallowed.
+   */
+  emitStatus: (event: RuntimeStatusEvent) => void;
 }
 
 const log = consoleLogger;
@@ -189,6 +197,13 @@ export abstract class NdjsonStreamAdapter implements RuntimeAdapter {
           seq,
           emitBlock: (b) => opts.onBlock?.(b),
           appendAssistantText,
+          emitStatus: (e) => {
+            try {
+              opts.onStatus?.(e);
+            } catch (err) {
+              log.warn(`${this.id} onStatus threw`, { err: String(err) });
+            }
+          },
         });
       } catch (err) {
         log.warn(`${this.id} event handler threw`, { err: String(err) });