@botcord/daemon 0.2.13 → 0.2.15

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) {

package/dist/gateway/types.d.ts

@@ -198,6 +198,18 @@ export interface ChannelStreamBlockContext {
     block: unknown;
     log: GatewayLogger;
 }
+/**
+ * Context passed to `ChannelAdapter.typing()` when the dispatcher signals
+ * "agent has accepted this turn but no execution block has surfaced yet".
+ * Adapters that bridge to a presence-style API (BotCord `/hub/typing`, etc.)
+ * map this into a one-shot ephemeral notification.
+ */
+export interface ChannelTypingContext {
+    traceId: string;
+    accountId: string;
+    conversationId: string;
+    log: GatewayLogger;
+}
 /** Upstream messaging surface such as BotCord, Telegram, or WeChat. */
 export interface ChannelAdapter {
     readonly id: string;
@@ -207,16 +219,48 @@ export interface ChannelAdapter {
     send(ctx: ChannelSendContext): Promise<ChannelSendResult>;
     status?(): ChannelStatusSnapshot;
     streamBlock?(ctx: ChannelStreamBlockContext): Promise<void>;
+    /**
+     * Optional ephemeral "agent is responding" hint. Fire-and-forget; failures
+     * must not break the turn. Channels without a presence concept should leave
+     * this undefined.
+     */
+    typing?(ctx: ChannelTypingContext): Promise<void>;
 }
 /** One parsed block from a runtime's streaming output, forwarded via `onBlock`. */
 export interface StreamBlock {
     /** Raw JSON object as emitted by the underlying CLI (e.g. claude-code stream-json). */
     raw: unknown;
-    /** Normalized kind, used by channels to decide whether to forward progressive output. */
-    kind: "assistant_text" | "tool_use" | "tool_result" | "system" | "other";
+    /**
+     * Normalized kind, used by channels to decide whether to forward progressive
+     * output. `thinking` is synthesized by the dispatcher (or emitted explicitly
+     * by an adapter) to represent "the runtime is busy but has nothing visible
+     * to show yet" — see `RuntimeStatusEvent`.
+     */
+    kind: "assistant_text" | "tool_use" | "tool_result" | "system" | "thinking" | "other";
     /** 1-based sequence number within this turn. */
     seq: number;
 }
+/**
+ * Lightweight lifecycle event emitted by runtime adapters and consumed by the
+ * dispatcher to drive Dashboard-side `typing` / `thinking` UI states. Not
+ * exposed to channels directly — the dispatcher decides how to forward.
+ *
+ *   - `typing`   — ephemeral presence; dispatcher pings the channel's
+ *                  `typing()` API on `started`. `stopped` is observed for
+ *                  internal bookkeeping but not forwarded (frontend clears on
+ *                  stream/message arrival).
+ *   - `thinking` — trace-bound execution state; dispatcher converts each
+ *                  event into a `kind: "thinking"` stream block.
+ */
+export type RuntimeStatusEvent = {
+    kind: "typing";
+    phase: "started" | "stopped";
+} | {
+    kind: "thinking";
+    phase: "started" | "updated" | "stopped";
+    label?: string;
+    raw?: unknown;
+};
 /** Options passed to a runtime adapter for a single turn. */
 export interface RuntimeRunOptions {
     text: string;
@@ -247,6 +291,14 @@ export interface RuntimeRunOptions {
     context?: Record<string, unknown>;
     /** Called for every parsed block while the turn is in progress. */
     onBlock?: (block: StreamBlock) => void;
+    /**
+     * Optional lifecycle hook for `typing` / `thinking` status. Adapters that
+     * can identify session/turn/tool transitions before any `StreamBlock` is
+     * available should emit through here so the dispatcher can drive
+     * Dashboard-side state. Errors from this callback must be swallowed
+     * by the adapter — the dispatcher's handler is fire-and-forget.
+     */
+    onStatus?: (event: RuntimeStatusEvent) => void;
     /**
      * External service endpoint required by some runtimes (first user:
      * openclaw-acp). Resolved at config-load time and passed through here per

package/dist/index.js

@@ -33,7 +33,7 @@ Usage: botcord-daemon <command> [options]
 
 Commands:
   start [--background|-d] [--relogin] [--hub <url>] [--label <name>]
-        [--agent <ag_xxx> ...] [--cwd <path>]
+        [--install-token <dit_xxx>] [--agent <ag_xxx> ...] [--cwd <path>]
                                           Start the daemon in the foreground by
                                           default. Pass --background (alias -d)
                                           to detach and return to the shell.
@@ -42,6 +42,9 @@ Commands:
                                           first. --hub defaults to ${DEFAULT_HUB}
                                           (or the URL stored in a previous
                                           login). --relogin forces re-login.
+                                          --install-token redeems a dashboard
+                                          issued one-time install ticket for
+                                          non-interactive first start.
                                           --label is sent to the Hub on connect
                                           for the dashboard device list
                                           (defaults to hostname). Non-TTY
@@ -213,6 +216,52 @@ function safeLoadUserAuth() {
 function delay(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+function parseDaemonTokenResponse(raw, fallbackHubUrl) {
+    const obj = (raw && typeof raw === "object" ? raw : {});
+    const pick = (camel, snake) => obj[camel] ?? obj[snake];
+    const accessToken = pick("accessToken", "access_token");
+    const refreshToken = pick("refreshToken", "refresh_token");
+    const expiresIn = pick("expiresIn", "expires_in");
+    const userId = pick("userId", "user_id");
+    const daemonInstanceId = pick("daemonInstanceId", "daemon_instance_id");
+    const hubUrl = pick("hubUrl", "hub_url");
+    if (typeof accessToken !== "string" || !accessToken) {
+        throw new Error("daemon auth response missing accessToken");
+    }
+    if (typeof refreshToken !== "string" || !refreshToken) {
+        throw new Error("daemon auth response missing refreshToken");
+    }
+    if (typeof userId !== "string" || !userId) {
+        throw new Error("daemon auth response missing userId");
+    }
+    if (typeof daemonInstanceId !== "string" || !daemonInstanceId) {
+        throw new Error("daemon auth response missing daemonInstanceId");
+    }
+    return {
+        accessToken,
+        refreshToken,
+        expiresIn: typeof expiresIn === "number" && expiresIn > 0 ? expiresIn : 3600,
+        userId,
+        daemonInstanceId,
+        hubUrl: typeof hubUrl === "string" && hubUrl.length > 0 ? hubUrl : fallbackHubUrl,
+    };
+}
+async function redeemInstallToken(opts) {
+    const body = { install_token: opts.installToken };
+    if (opts.label)
+        body.label = opts.label;
+    const resp = await fetch(`${opts.hubUrl.replace(/\/+$/, "")}/daemon/auth/install-token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        throw new Error(`daemon install-token redeem failed: ${resp.status} ${text}`);
+    }
+    return parseDaemonTokenResponse(await resp.json(), opts.hubUrl);
+}
 /**
  * Run the device-code login flow against the given Hub. Polls every
  * `interval` seconds (the Hub may bump this) until the user authorizes
@@ -280,15 +329,16 @@ async function runDeviceCodeFlow(opts) {
  * plane (legacy P0 behavior — caller may still log a warning).
  *
  * Decision tree (plan §4.4 + §6.4):
- * 1. `--relogin` → device-code login.
- * 2. Have valid creds (not near expiry) → return existing record.
- * 3. Have stale creds → leave as-is; the control channel will refresh.
+ * 1. Have existing creds and no `--relogin` → return existing record.
+ * 2. `--install-token` → redeem the one-time dashboard ticket.
+ * 3. `--relogin` → device-code login.
  * 4. No creds + TTY → device-code login.
  * 5. No creds + no TTY → exit 1 with the §6.4 hint.
  */
 async function ensureUserAuthForStart(args) {
     const hubFlag = typeof args.flags.hub === "string" ? args.flags.hub : undefined;
     const labelFlag = typeof args.flags.label === "string" ? args.flags.label : undefined;
+    const installToken = typeof args.flags["install-token"] === "string" ? args.flags["install-token"] : undefined;
     const relogin = args.flags.relogin === true;
     const existing = safeLoadUserAuth();
     if (!relogin && existing) {
@@ -305,10 +355,28 @@ async function ensureUserAuthForStart(args) {
         if (labelFlag && existing.label !== labelFlag) {
             console.error(`note: --label "${labelFlag}" ignored (already logged in as "${existing.label ?? "<unset>"}"); pass --relogin to change it`);
         }
+        if (installToken) {
+            console.error("note: --install-token ignored because daemon is already logged in");
+        }
         return existing;
     }
     // Need a fresh login. Resolve hubUrl: explicit --hub > existing record > DEFAULT_HUB.
     const hubUrl = hubFlag ?? existing?.hubUrl ?? DEFAULT_HUB;
+    const label = labelFlag ?? defaultLoginLabel();
+    if (installToken) {
+        const tok = await redeemInstallToken({ hubUrl, installToken, label });
+        const record = userAuthFromTokenResponse(tok, { label });
+        saveUserAuth(record);
+        clearAuthExpiredFlag();
+        log.info("install-token flow: authorized", {
+            userId: record.userId,
+            daemonInstanceId: record.daemonInstanceId,
+            hubUrl: record.hubUrl,
+            label,
+        });
+        console.log(`Logged in as ${record.userId}`);
+        return record;
+    }
     if (!process.stdin.isTTY) {
         // Plan §6.4 — non-interactive environment. Fail fast with actionable
         // remediation; never block waiting for input that will never arrive.
@@ -317,7 +385,6 @@ async function ensureUserAuthForStart(args) {
         console.error("       or mount a valid `~/.botcord/daemon/user-auth.json`");
         process.exit(1);
     }
-    const label = labelFlag ?? defaultLoginLabel();
     return runDeviceCodeFlow({ hubUrl, label });
 }
 async function cmdStart(args) {

package/dist/provision.js

@@ -580,9 +580,11 @@ export async function adoptDiscoveredOpenclawAgents(ctx) {
                     return;
                 }
                 try {
+                    const name = resolveOpenclawIdentityName(oc.id, oc.workspace) ?? oc.name ?? `openclaw-${oc.id}`;
                     const params = {
                         runtime: "openclaw-acp",
-                        name: oc.name ?? `openclaw-${oc.id}`,
+                        name,
+                        bio: `OpenClaw agent ${oc.id} adopted from gateway ${gw.name}.`,
                         openclaw: { gateway: gw.name, agent: oc.id },
                     };
                     const credentials = await materializeCredentials(params, freshCfg, {
@@ -1006,6 +1008,9 @@ function readLocalOpenclawAgents() {
                 row.name = raw.name;
             if (typeof raw?.workspace === "string")
                 row.workspace = raw.workspace;
+            const identityName = resolveOpenclawIdentityName(id, row.workspace, cfg);
+            if (identityName)
+                row.name = identityName;
             const m = raw?.model;
             if (m && typeof m === "object") {
                 const model = {};
@@ -1030,6 +1035,63 @@ function readLocalOpenclawAgents() {
         return null;
     }
 }
+function resolveOpenclawIdentityName(agentId, workspace, cfg) {
+    const root = workspace ?? resolveOpenclawWorkspace(agentId, cfg);
+    if (!root)
+        return undefined;
+    const file = path.join(expandHomePath(root), "IDENTITY.md");
+    try {
+        if (!existsSync(file))
+            return undefined;
+        return parseIdentityName(readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveOpenclawWorkspace(agentId, cfg) {
+    let parsed = cfg;
+    if (!parsed) {
+        try {
+            const file = path.join(homedir(), ".openclaw", "openclaw.json");
+            if (!existsSync(file))
+                return undefined;
+            parsed = JSON.parse(readFileSync(file, "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const defaults = parsed?.agents?.defaults;
+    const defaultId = typeof defaults?.id === "string" && defaults.id ? defaults.id : "default";
+    if ((agentId === defaultId || agentId === "default") && typeof defaults?.workspace === "string") {
+        return defaults.workspace;
+    }
+    const list = Array.isArray(parsed?.agents?.list) ? parsed.agents.list : [];
+    for (const entry of list) {
+        if (entry?.id === agentId && typeof entry.workspace === "string")
+            return entry.workspace;
+    }
+    return undefined;
+}
+function parseIdentityName(raw) {
+    for (const line of raw.split(/\r?\n/)) {
+        const m = line.match(/^\s*-\s*\*\*Name:\*\*\s*(.+?)\s*$/i);
+        if (!m)
+            continue;
+        const name = m[1].trim();
+        if (name && !name.startsWith("_("))
+            return name;
+    }
+    return undefined;
+}
+function expandHomePath(p) {
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return path.join(homedir(), p.slice(2));
+    return p;
+}
 /**
  * Async variant that includes L2 (gateway reachability) and L3 (agent listing)
  * probes for runtimes that talk to external services. Used by the production

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/__tests__/agent-workspace.test.ts

@@ -80,6 +80,31 @@ describe("ensureAgentWorkspace", () => {
     expect(existsSync(path.join(agentWorkspaceDir("ag_notes"), "notes", ".gitkeep"))).toBe(true);
   });
 
+  it("seeds bundled Claude Code skills under .claude/skills/", () => {
+    ensureAgentWorkspace("ag_skills", {});
+    const skillsDir = path.join(agentWorkspaceDir("ag_skills"), ".claude", "skills");
+    expect(existsSync(path.join(skillsDir, "botcord", "SKILL.md"))).toBe(true);
+    expect(existsSync(path.join(skillsDir, "botcord-user-guide", "SKILL.md"))).toBe(true);
+  });
+
+  it("re-seeds skills on a second call so daemon upgrades propagate", () => {
+    ensureAgentWorkspace("ag_skill_upgrade", {});
+    const skillFile = path.join(
+      agentWorkspaceDir("ag_skill_upgrade"),
+      ".claude",
+      "skills",
+      "botcord",
+      "SKILL.md",
+    );
+    writeFileSync(skillFile, "stale content from a prior daemon version\n");
+
+    ensureAgentWorkspace("ag_skill_upgrade", {});
+
+    const reseeded = readFileSync(skillFile, "utf8");
+    expect(reseeded).not.toBe("stale content from a prior daemon version\n");
+    expect(reseeded).toContain("name: botcord");
+  });
+
   it("does not overwrite a user-modified memory.md on a second call", () => {
     ensureAgentWorkspace("ag_keep", {});
     const memoryPath = path.join(agentWorkspaceDir("ag_keep"), "memory.md");

package/src/__tests__/provision.test.ts

@@ -823,7 +823,11 @@ describe("adoptDiscoveredOpenclawAgents", () => {
       });
 
       expect(res.adopted).toEqual(["ag_adopted"]);
-      expect(register).toHaveBeenCalledWith("https://hub.example", "Main Agent", undefined);
+      expect(register).toHaveBeenCalledWith(
+        "https://hub.example",
+        "Main Agent",
+        "OpenClaw agent main adopted from gateway local.",
+      );
       const saved = JSON.parse(
         fs.readFileSync(nodePath.join(credDir, "ag_adopted.json"), "utf8"),
       ) as Record<string, unknown>;
@@ -882,6 +886,69 @@ describe("adoptDiscoveredOpenclawAgents", () => {
       expect(register).not.toHaveBeenCalled();
     });
   });
+
+  it("uses the OpenClaw workspace identity name when agents.list has no name", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      const credDir = nodePath.join(tmp, ".botcord", "credentials");
+      fs.mkdirSync(credDir, { recursive: true });
+      fs.writeFileSync(
+        nodePath.join(credDir, "ag_seed.json"),
+        JSON.stringify({
+          version: 1,
+          hubUrl: "https://hub.example",
+          agentId: "ag_seed",
+          keyId: "k_seed",
+          privateKey: Buffer.alloc(32, 7).toString("base64"),
+          savedAt: new Date().toISOString(),
+        }),
+      );
+      const ocWorkspace = nodePath.join(tmp, ".openclaw", "workspace-swe");
+      fs.mkdirSync(ocWorkspace, { recursive: true });
+      fs.writeFileSync(
+        nodePath.join(ocWorkspace, "IDENTITY.md"),
+        ["# IDENTITY.md", "", "- **Name:** Danny", "- **Vibe:** ships fast"].join("\n"),
+      );
+      fs.writeFileSync(
+        nodePath.join(tmp, ".openclaw", "openclaw.json"),
+        JSON.stringify({
+          agents: {
+            defaults: { workspace: nodePath.join(tmp, ".openclaw", "workspace") },
+            list: [{ id: "swe", workspace: ocWorkspace }],
+          },
+        }),
+      );
+      mockState.cfg = {
+        defaultRoute: { adapter: "claude-code", cwd: "/tmp" },
+        routes: [],
+        streamBlocks: true,
+        agents: ["ag_seed"],
+        openclawGateways: [{ name: "local", url: "ws://127.0.0.1:18789" }],
+      };
+
+      const register = vi.fn(async () => ({
+        agentId: "ag_swe",
+        keyId: "k_swe",
+        privateKey: Buffer.alloc(32, 33).toString("base64"),
+        publicKey: Buffer.alloc(32, 34).toString("base64"),
+        hubUrl: "https://hub.example",
+        token: "tok",
+        expiresAt: Date.now() + 60_000,
+      }));
+
+      await adoptDiscoveredOpenclawAgents({
+        gateway: makeFakeGateway(["ag_seed"]) as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["gateway"],
+        register: register as unknown as Parameters<typeof adoptDiscoveredOpenclawAgents>[0]["register"],
+        cfg: mockState.cfg as unknown as DaemonConfig,
+        probe: async () => ({ ok: true, agents: [{ id: "swe" }] }),
+      });
+
+      expect(register).toHaveBeenCalledWith(
+        "https://hub.example",
+        "Danny",
+        "OpenClaw agent swe adopted from gateway local.",
+      );
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/agent-workspace.ts

@@ -19,6 +19,7 @@
 import {
   chmodSync,
   copyFileSync,
+  cpSync,
   existsSync,
   lstatSync,
   mkdirSync,
@@ -28,9 +29,12 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import path from "node:path";
 
+const require = createRequire(import.meta.url);
+
 // Accepted agent id pattern. Enforced at every path-builder entry so a
 // malicious / malformed agentId (e.g. "../../etc") cannot escape
 // ~/.botcord/agents/ and end up under `rmSync(..., { recursive: true })`
@@ -364,6 +368,48 @@ export function ensureAgentHermesWorkspace(agentId: string): {
   return { hermesHome, hermesWorkspace };
 }
 
+/**
+ * Bundled Claude Code skills shipped inside `@botcord/cli/skills/`. Seeded
+ * into every agent workspace so the spawned `claude` runtime (which loads
+ * `.claude/` via `--setting-sources project`) can discover the BotCord CLI
+ * skill without any manual setup.
+ */
+const BUNDLED_CC_SKILLS = ["botcord", "botcord-user-guide"] as const;
+
+function resolveBundledCliSkillsRoot(): string | null {
+  try {
+    const pkgJsonPath = require.resolve("@botcord/cli/package.json");
+    const root = path.join(path.dirname(pkgJsonPath), "skills");
+    return existsSync(root) ? root : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Copy daemon-owned Claude Code skills into the workspace. Re-copied on every
+ * `ensureAgentWorkspace` call (force-overwrite) so daemon upgrades propagate;
+ * users wanting custom skills should pick a different directory name under
+ * `.claude/skills/` — those are not touched here.
+ */
+function seedClaudeCodeSkills(workspace: string): void {
+  const sourceRoot = resolveBundledCliSkillsRoot();
+  if (!sourceRoot) return;
+  const skillsDir = path.join(workspace, ".claude", "skills");
+  mkdirTolerant(path.join(workspace, ".claude"));
+  mkdirTolerant(skillsDir);
+  for (const name of BUNDLED_CC_SKILLS) {
+    const src = path.join(sourceRoot, name);
+    if (!existsSync(src)) continue;
+    const dst = path.join(skillsDir, name);
+    try {
+      cpSync(src, dst, { recursive: true, force: true, dereference: true });
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
 /**
  * Idempotently create the agent's home / workspace / state directories and
  * seed the workspace Markdown files. Existing files are never overwritten —
@@ -392,6 +438,7 @@ export function ensureAgentWorkspace(agentId: string, seed: WorkspaceSeed): void
   writeIfMissing(path.join(workspace, "memory.md"), MEMORY_MD);
   writeIfMissing(path.join(workspace, "task.md"), TASK_MD);
   writeIfMissing(path.join(notes, ".gitkeep"), "");
+  seedClaudeCodeSkills(workspace);
 }
 
 /** Patch fields accepted by {@link applyAgentIdentity}. `bio = null` clears it. */

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -510,6 +510,103 @@ describe("createBotCordChannel — streamBlock()", () => {
       globalThis.fetch = realFetch;
     }
   });
+
+  it("normalizes a thinking block with phase/label/source payload", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "trace_thk",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "thinking",
+          seq: 7,
+          raw: { phase: "updated", label: "Searching web", source: "runtime" },
+        },
+        log: silentLog,
+      });
+      const body = JSON.parse(fetchSpy.mock.calls[0][1].body as string);
+      expect(body.block).toEqual({
+        kind: "thinking",
+        seq: 7,
+        payload: { phase: "updated", label: "Searching web", source: "runtime" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+});
+
+describe("createBotCordChannel — typing()", () => {
+  it("POSTs to /hub/typing with the room id", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.typing!({
+        traceId: "trace_typ",
+        accountId: "ag_self",
+        conversationId: "rm_oc_42",
+        log: silentLog,
+      });
+      expect(fetchSpy).toHaveBeenCalledTimes(1);
+      const [url, init] = fetchSpy.mock.calls[0];
+      expect(url).toBe("https://hub.example.com/hub/typing");
+      expect(init.method).toBe("POST");
+      const body = JSON.parse(init.body as string);
+      expect(body).toEqual({ room_id: "rm_oc_42" });
+      expect((init.headers as Record<string, string>).Authorization).toBe("Bearer test-token");
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("swallows fetch failures (fire-and-forget)", async () => {
+    const fetchSpy = vi.fn().mockRejectedValue(new Error("network down"));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client: makeClient(),
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await expect(
+        channel.typing!({
+          traceId: "t",
+          accountId: "ag_self",
+          conversationId: "rm_oc_1",
+          log: silentLog,
+        }),
+      ).resolves.toBeUndefined();
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------