@botcord/daemon 0.2.13 → 0.2.14

package/dist/gateway/channels/botcord.js

@@ -581,6 +581,32 @@ export function createBotCordChannel(options) {
                 ctx.log.warn("botcord stream-block failed", { err: String(err) });
             }
         },
+        async typing(ctx) {
+            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() {
             return { ...statusSnapshot };
         },
@@ -667,6 +693,19 @@ function normalizeBlockForHub(block, seq) {
             payload.model = raw.model;
         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")

package/dist/gateway/dispatcher.d.ts

@@ -94,6 +94,12 @@ export declare class Dispatcher {
     private readonly resolveHubUrl?;
     private readonly transcript;
     private readonly queues;
+    /**
+     * 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;
     constructor(opts: DispatcherOptions);
     /** Consume one inbound envelope, ack it once ownership is decided, then run its turn. */
     handle(envelope: GatewayInboundEnvelope): Promise<void>;

package/dist/gateway/dispatcher.js

@@ -18,6 +18,14 @@ const MAX_BATCH_BUFFER_ENTRIES = 40;
  * runtime prompt stays bounded even if the channel-side batch was huge.
  */
 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;
 /**
  * Reason carried on `AbortController.abort()` when a cancel-previous wave
  * is taking over the slot. Distinguishing this from a timeout abort lets
@@ -63,6 +71,12 @@ export class Dispatcher {
     resolveHubUrl;
     transcript;
     queues = 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.
+     */
+    recentTypingPings = new Map();
     constructor(opts) {
         this.config = opts.config;
         this.channels = opts.channels;
@@ -551,26 +565,204 @@ 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) => {
-                recordBlock(block);
-                // Fire-and-forget: stream errors must not break the turn.
-                channel
-                    .streamBlock({
+                // 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: { ...block, seq: blocksSent },
                     log: this.log,
-                })
-                    .catch((err) => {
-                    this.log.warn("dispatcher: streamBlock failed", {
+                };
+                // 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.catch === "function") {
+                        ret.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, label, source) => {
+            if (!forwardBlockToChannel)
+                return;
+            const raw = { phase, source };
+            if (label)
+                raw.label = label;
+            const synth = { 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 = () => {
+            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.catch === "function") {
+                    ret.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) => {
+                // 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) => {
+                // 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 = () => {
+            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.
@@ -605,6 +797,7 @@ export class Dispatcher {
                     trustLevel,
                     systemContext,
                     onBlock,
+                    onStatus,
                     gateway: route.gateway,
                 });
             }
@@ -841,6 +1034,11 @@ export class Dispatcher {
             });
         }
         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/dist/gateway/runtimes/acp-stream.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult, StreamBlock } from "../types.js";
+import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult, RuntimeStatusEvent, StreamBlock } from "../types.js";
 /** ACP protocol version this client targets. */
 export declare const ACP_PROTOCOL_VERSION = 1;
 export interface AcpInitializeResult {
@@ -66,6 +66,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;
 }

package/dist/gateway/runtimes/acp-stream.js

@@ -267,6 +267,14 @@ export class AcpRuntimeAdapter {
                     this.onUpdate(params, {
                         appendAssistantText,
                         emitBlock: (b) => opts.onBlock?.(b),
+                        emitStatus: (e) => {
+                            try {
+                                opts.onStatus?.(e);
+                            }
+                            catch (err) {
+                                log.warn(`${this.id} onStatus threw`, { err: String(err) });
+                            }
+                        },
                         seq,
                     });
                 }
@@ -335,6 +343,17 @@ export class AcpRuntimeAdapter {
             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.
             try {

package/dist/gateway/runtimes/claude-code.js

@@ -117,6 +117,11 @@ export class ClaudeCodeAdapter extends NdjsonStreamAdapter {
     }
     handleEvent(raw, ctx) {
         const obj = raw;
+        // 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) {
             ctx.state.newSessionId = String(obj.session_id);
@@ -153,6 +158,35 @@ 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) {
+    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, seq) {
     let kind = "other";
     if (obj?.type === "assistant") {

package/dist/gateway/runtimes/codex.js

@@ -208,6 +208,12 @@ export class CodexAdapter extends NdjsonStreamAdapter {
     }
     handleEvent(raw, ctx) {
         const obj = raw;
+        // 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
         // instead of spawning fresh. Safe now that systemContext lives in
@@ -240,6 +246,50 @@ 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) {
+    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) {
+    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/dist/gateway/runtimes/hermes-agent.d.ts

@@ -71,10 +71,15 @@ export declare 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;
     /**

package/dist/gateway/runtimes/hermes-agent.js

@@ -153,32 +153,45 @@ 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.
      */
     onUpdate(params, ctx) {
         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 = "other";
+        let assistantTextSeen = false;
         if (kind === "agent_message_chunk") {
             const content = update
                 .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 });
     }
     /**
@@ -202,3 +215,20 @@ 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, update, assistantTextSeen) {
+    // `agent_thought_chunk` is handled inline in `onUpdate` (status-only path).
+    if (kind === "tool_call" || kind === "tool_call_update") {
+        const tool = update.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/dist/gateway/runtimes/ndjson-stream.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult, StreamBlock } from "../types.js";
+import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult, RuntimeStatusEvent, StreamBlock } from "../types.js";
 /**
  * Mutable state threaded through event callbacks while a single turn runs.
  * The base class reads these fields to assemble the final RuntimeRunResult.
@@ -29,6 +29,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;
 }
 /** Base class for runtime adapters that drive a CLI emitting newline-delimited JSON. */
 export declare abstract class NdjsonStreamAdapter implements RuntimeAdapter {

package/dist/gateway/runtimes/ndjson-stream.js

@@ -136,6 +136,14 @@ export class NdjsonStreamAdapter {
                     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) {