@botcord/daemon 0.2.20 → 0.2.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.20",
+  "version": "0.2.22",
   "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

@@ -12,11 +12,13 @@ import os from "node:os";
 import path from "node:path";
 
 import {
+  agentCodexHomeDir,
   agentHermesHomeDir,
   agentHomeDir,
   agentStateDir,
   agentWorkspaceDir,
   applyAgentIdentity,
+  ensureAgentCodexHome,
   ensureAgentHermesWorkspace,
   ensureAgentWorkspace,
 } from "../agent-workspace.js";
@@ -105,6 +107,49 @@ describe("ensureAgentWorkspace", () => {
     expect(reseeded).toContain("name: botcord");
   });
 
+  it("seeds bundled skills under codex-home/skills/ so per-agent CODEX_HOME sees them", () => {
+    ensureAgentWorkspace("ag_codex_skills", {});
+    const skillsDir = path.join(agentCodexHomeDir("ag_codex_skills"), "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 codex skills on subsequent ensureAgentCodexHome calls", () => {
+    ensureAgentCodexHome("ag_codex_reseed");
+    const skillFile = path.join(
+      agentCodexHomeDir("ag_codex_reseed"),
+      "skills",
+      "botcord",
+      "SKILL.md",
+    );
+    writeFileSync(skillFile, "stale content from a prior daemon version\n");
+
+    ensureAgentCodexHome("ag_codex_reseed");
+
+    const reseeded = readFileSync(skillFile, "utf8");
+    expect(reseeded).not.toBe("stale content from a prior daemon version\n");
+    expect(reseeded).toContain("name: botcord");
+  });
+
+  it("seeds bundled skills under hermes-home/skills/ so per-agent HERMES_HOME sees them", () => {
+    const { hermesHome } = ensureAgentHermesWorkspace("ag_hermes_skills");
+    const skillsDir = path.join(hermesHome, "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 hermes skills on subsequent ensureAgentHermesWorkspace calls", () => {
+    const { hermesHome } = ensureAgentHermesWorkspace("ag_hermes_reseed");
+    const skillFile = path.join(hermesHome, "skills", "botcord", "SKILL.md");
+    writeFileSync(skillFile, "stale content from a prior daemon version\n");
+
+    ensureAgentHermesWorkspace("ag_hermes_reseed");
+
+    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

@@ -778,6 +778,86 @@ describe("provision_agent seeds workspace + hot-adds managed route", () => {
       expect(gw.listManagedRoutes()).toHaveLength(0);
     });
   });
+
+  // Regression: the daemon's per-agent caches (credentialPathByAgentId,
+  // hubUrlByAgentId, displayNameByAgent) used to be seeded only at boot.
+  // Hot-provisioning then left those caches missing the new agent until the
+  // next restart, and `room-context-fetcher` logged
+  // `daemon.room-context.no-credentials` on every turn. This contract test
+  // pins the install path: a successful provision MUST fire the hook with
+  // the credential file + hub URL + display name.
+  it("fires onAgentInstalled after a successful install so daemon caches stay warm", async () => {
+    await withSandboxHome(async ({ tmp, path: nodePath }) => {
+      const gw = makeFakeGateway();
+      const installed: Array<Record<string, unknown>> = [];
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+        onAgentInstalled: (info) => {
+          installed.push({ ...info });
+        },
+      });
+      const privateKey = Buffer.alloc(32, 41).toString("base64");
+      const ack = await provisioner({
+        id: "req_hook",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          // `name` only flows into `displayName` on the slow (daemon-register)
+          // path. Hub's fast path carries it via `credentials.displayName`.
+          runtime: "claude-code",
+          credentials: {
+            agentId: "ag_hook",
+            keyId: "k_hook",
+            privateKey,
+            hubUrl: "https://hub.example",
+            displayName: "zhejian's cc",
+          },
+        },
+      });
+      expect(ack.ok).toBe(true);
+      expect(installed).toHaveLength(1);
+      const credFile = nodePath.join(tmp, ".botcord", "credentials", "ag_hook.json");
+      expect(installed[0]).toMatchObject({
+        agentId: "ag_hook",
+        credentialsFile: credFile,
+        hubUrl: "https://hub.example",
+        displayName: "zhejian's cc",
+        runtime: "claude-code",
+      });
+    });
+  });
+
+  // The hook is best-effort wiring, not part of the install transaction.
+  // A throwing hook must not roll back the install (the agent is already
+  // on disk and in the gateway), and must not flip the control-frame ack
+  // to failure — the operator only sees a loud error log.
+  it("does not roll back the install when onAgentInstalled throws", async () => {
+    await withSandboxHome(async ({ tmp, fs, path: nodePath }) => {
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+        onAgentInstalled: () => {
+          throw new Error("hook boom");
+        },
+      });
+      const privateKey = Buffer.alloc(32, 43).toString("base64");
+      const ack = await provisioner({
+        id: "req_hook_throws",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          credentials: {
+            agentId: "ag_hookboom",
+            keyId: "k_hb",
+            privateKey,
+            hubUrl: "https://hub.example",
+          },
+        },
+      });
+      expect(ack.ok).toBe(true);
+      const credFile = nodePath.join(tmp, ".botcord", "credentials", "ag_hookboom.json");
+      expect(fs.existsSync(credFile)).toBe(true);
+      expect(gw.listManagedRoutes()).toHaveLength(1);
+    });
+  });
 });
 
 describe("adoptDiscoveredOpenclawAgents", () => {

package/src/agent-workspace.ts

@@ -333,14 +333,18 @@ function isSymlink(p: string): boolean {
 }
 
 /**
- * Idempotently create the per-agent CODEX_HOME directory and link the
- * user's codex `auth.json` into it. Does NOT write an initial `AGENTS.md`
- * — the codex adapter writes it fresh per turn from `systemContext`.
+ * Idempotently create the per-agent CODEX_HOME directory, link the
+ * user's codex `auth.json` into it, and seed the bundled BotCord skills
+ * under `<dir>/skills/` so the codex runtime (which sees this as
+ * `CODEX_HOME`, not the user's `~/.codex`) can discover them. Does NOT
+ * write an initial `AGENTS.md` — the codex adapter writes it fresh per
+ * turn from `systemContext`.
  */
 export function ensureAgentCodexHome(agentId: string): string {
   const dir = agentCodexHomeDir(agentId);
   mkdirTolerant(dir);
   linkCodexAuth(dir);
+  seedCodexSkills(dir);
   return dir;
 }
 
@@ -348,7 +352,10 @@ export function ensureAgentCodexHome(agentId: string): string {
  * Idempotently create the per-agent HERMES_HOME and HERMES workspace
  * directories. Writes a stub `.env` inside HERMES_HOME so hermes-acp's
  * `_load_env` does not log "No .env found" on every spawn; users can edit
- * this file to add API keys / model overrides.
+ * this file to add API keys / model overrides. Also seeds the bundled
+ * BotCord skills under `<hermes-home>/skills/` so hermes-acp's skill
+ * loader (which only sees this isolated HERMES_HOME, not `~/.hermes`)
+ * can discover them.
  */
 export function ensureAgentHermesWorkspace(agentId: string): {
   hermesHome: string;
@@ -365,16 +372,21 @@ export function ensureAgentHermesWorkspace(agentId: string): {
   );
   seedHermesConfig(hermesHome);
   mergeHermesProviderEnv(path.join(hermesHome, ".env"));
+  seedHermesAgentSkills(hermesHome);
   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.
+ * Bundled BotCord skills shipped inside `@botcord/cli/skills/`. Skill
+ * content (SKILL.md + helper scripts) is runtime-agnostic; only the
+ * discovery path differs:
+ *   - Claude Code: `<workspace>/.claude/skills/<name>/`
+ *   - Codex:       `<codex-home>/skills/<name>/`
+ *   - Hermes:      `<hermes-home>/skills/<name>/`
+ * Seeded fresh per `ensureAgent*` call (force-overwrite) so daemon
+ * upgrades propagate.
  */
-const BUNDLED_CC_SKILLS = ["botcord", "botcord-user-guide"] as const;
+const BUNDLED_SKILLS = ["botcord", "botcord-user-guide"] as const;
 
 function resolveBundledCliSkillsRoot(): string | null {
   try {
@@ -387,21 +399,19 @@ function resolveBundledCliSkillsRoot(): string | 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.
+ * Copy bundled skill directories into `destSkillsDir`, force-overwriting
+ * any prior copy of each named skill. Other entries in `destSkillsDir`
+ * are left alone so user-authored skills survive. Best-effort: silently
+ * skips on copy failure or when the bundled CLI isn't resolvable.
  */
-function seedClaudeCodeSkills(workspace: string): void {
+function copyBundledSkills(destSkillsDir: 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) {
+  mkdirTolerant(destSkillsDir);
+  for (const name of BUNDLED_SKILLS) {
     const src = path.join(sourceRoot, name);
     if (!existsSync(src)) continue;
-    const dst = path.join(skillsDir, name);
+    const dst = path.join(destSkillsDir, name);
     try {
       cpSync(src, dst, { recursive: true, force: true, dereference: true });
     } catch {
@@ -410,6 +420,37 @@ function seedClaudeCodeSkills(workspace: string): void {
   }
 }
 
+/**
+ * Seed Claude Code's `.claude/skills/` discovery dir under the agent
+ * workspace. The `claude` adapter spawns with `--setting-sources project`
+ * so this dir is auto-discovered.
+ */
+function seedClaudeCodeSkills(workspace: string): void {
+  mkdirTolerant(path.join(workspace, ".claude"));
+  copyBundledSkills(path.join(workspace, ".claude", "skills"));
+}
+
+/**
+ * Seed Codex's `<CODEX_HOME>/skills/` discovery dir. The codex adapter
+ * sets `CODEX_HOME=<agent>/codex-home/`, isolating per-agent skills from
+ * the user's global `~/.codex/skills/` — so skills must be seeded here
+ * for Codex agents to discover them.
+ */
+function seedCodexSkills(codexHome: string): void {
+  copyBundledSkills(path.join(codexHome, "skills"));
+}
+
+/**
+ * Seed Hermes's `<HERMES_HOME>/skills/` discovery dir. hermes-acp's
+ * skill loader scans `$HERMES_HOME/skills/` (primary) plus any
+ * `skills.external_dirs` from config; the daemon points hermes-acp at
+ * the per-agent `<hermes-home>/`, so the user's global
+ * `~/.hermes/skills/` is invisible — bundled skills must be seeded here.
+ */
+function seedHermesAgentSkills(hermesHome: string): void {
+  copyBundledSkills(path.join(hermesHome, "skills"));
+}
+
 /**
  * Idempotently create the agent's home / workspace / state directories and
  * seed the workspace Markdown files. Existing files are never overwritten —

package/src/daemon.ts

@@ -27,6 +27,7 @@ import {
   adoptDiscoveredOpenclawAgents,
   collectRuntimeSnapshot,
   createProvisioner,
+  type OnAgentInstalledHook,
 } from "./provision.js";
 import { openclawAutoProvisionEnabled } from "./openclaw-discovery.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
@@ -382,6 +383,34 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     });
   };
 
+  // Boot-seeded per-agent caches (`credentialPathByAgentId`,
+  // `hubUrlByAgentId`, `displayNameByAgent`, `scBuilders`) are scoped to
+  // the agents present at startup. Without this hook, agents added later
+  // via `provision_agent` or openclaw-adoption stay missing from those
+  // caches until the next daemon restart — `room-context-fetcher` then
+  // logs `daemon.room-context.no-credentials` on every turn for the new
+  // agent and the system context loses its `[BotCord Room]` block (member
+  // names, rule, role).
+  const onAgentInstalled: OnAgentInstalledHook = (info) => {
+    // Re-provision (e.g. credential rotation) overwrites in place so the
+    // next room-context fetch re-loads the BotCordClient against the new
+    // credential file.
+    credentialPathByAgentId.set(info.agentId, info.credentialsFile);
+    if (info.hubUrl) hubUrlByAgentId.set(info.agentId, info.hubUrl);
+    if (info.displayName) displayNameByAgent.set(info.agentId, info.displayName);
+    if (!scBuilders.has(info.agentId)) {
+      scBuilders.set(
+        info.agentId,
+        createDaemonSystemContextBuilder({
+          agentId: info.agentId,
+          activityTracker,
+          roomContextBuilder,
+          loopRiskBuilder,
+        }),
+      );
+    }
+  };
+
   const gateway = new Gateway({
     config: gwConfig,
     sessionStorePath: opts.sessionStorePath ?? SESSIONS_PATH,
@@ -437,6 +466,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       const adopted = await adoptDiscoveredOpenclawAgents({
         gateway,
         cfg: opts.config,
+        onAgentInstalled,
       });
       if (
         adopted.adopted.length > 0 ||
@@ -465,7 +495,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
       userId: userAuth.current.userId,
       hubUrl: userAuth.current.hubUrl,
     });
-    const provisioner = createProvisioner({ gateway, policyResolver });
+    const provisioner = createProvisioner({ gateway, policyResolver, onAgentInstalled });
     controlChannel = new ControlChannel({
       auth: userAuth,
       handle: provisioner,

package/src/gateway/channels/botcord.ts

@@ -30,7 +30,11 @@ const OWNER_CHAT_PREFIX = "rm_oc_";
 const DM_ROOM_PREFIX = "rm_dm_";
 const INBOX_POLL_LIMIT = 50;
 
-type InboxDrainTrigger = "ws_auth_ok" | "ws_inbox_update" | "coalesced_inbox_update";
+type InboxDrainTrigger =
+  | "ws_auth_ok"
+  | "ws_inbox_update"
+  | "coalesced_inbox_update"
+  | "has_more_continue";
 
 /** Minimal surface the adapter needs from `BotCordClient`. Matches the subset used at runtime. */
 export interface BotCordChannelClient {
@@ -309,7 +313,7 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
     emit: (env: GatewayInboundEnvelope) => Promise<void>,
     log: GatewayLogger,
     trigger: InboxDrainTrigger,
-  ): Promise<void> {
+  ): Promise<{ hasMore: boolean }> {
     const startedAt = Date.now();
     const resp = await client.pollInbox({ limit: INBOX_POLL_LIMIT, ack: false });
     const msgs = resp.messages ?? [];
@@ -334,7 +338,10 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
     const eligible: InboxMessage[] = [];
     if (msgs.length === 0) {
       logDrain();
-      return;
+      // Defensive: if Hub returns 0 messages, refuse to honor has_more=true.
+      // A stuck cursor on the Hub side could otherwise produce an unbounded
+      // poll loop here (count=0 with has_more=true on every iteration).
+      return { hasMore: false };
     }
 
     // First pass: ack duplicates/skipped messages so Hub stops requeueing,
@@ -370,7 +377,7 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
 
     if (eligible.length === 0) {
       logDrain();
-      return;
+      return { hasMore: Boolean(resp.has_more) };
     }
 
     // Group by `(room_id, topic)`. Insertion order is the poll order, so
@@ -384,6 +391,13 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       else groups.set(key, [msg]);
     }
 
+    // Emit groups in parallel: each `(room_id, topic)` group is an independent
+    // conversation thread, and the dispatcher already keys its per-turn queue
+    // by `(channel, accountId, roomId, threadId)` (see `buildQueueKey` in
+    // dispatcher.ts). Awaiting groups serially here forced a slow turn in
+    // room A to block room B's turn from starting; running them concurrently
+    // lets the dispatcher's per-room queues actually run in parallel.
+    const emitTasks: Promise<void>[] = [];
     for (const group of groups.values()) {
       const normalized = normalizeInboxBatch(group, {
         channelId: options.id,
@@ -409,17 +423,23 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
           },
         },
       };
-      try {
-        await emit(envelope);
-        emittedGroups += 1;
-      } catch (err) {
-        log.error("botcord emit threw", {
-          hubMsgIds: hubIds,
-          err: String(err),
-        });
-      }
+      emitTasks.push(
+        emit(envelope).then(
+          () => {
+            emittedGroups += 1;
+          },
+          (err) => {
+            log.error("botcord emit threw", {
+              hubMsgIds: hubIds,
+              err: String(err),
+            });
+          },
+        ),
+      );
     }
+    await Promise.all(emitTasks);
     logDrain();
+    return { hasMore: Boolean(resp.has_more) };
   }
 
   function startWsLoop(
@@ -470,11 +490,16 @@ export function createBotCordChannel(options: BotCordChannelOptions): ChannelAda
       processing = true;
       try {
         let currentTrigger = trigger;
+        let hasMore = false;
         do {
           pendingUpdate = false;
-          await drainInbox(client, emit, log, currentTrigger);
-          currentTrigger = "coalesced_inbox_update";
-        } while (pendingUpdate && running);
+          const result = await drainInbox(client, emit, log, currentTrigger);
+          hasMore = result.hasMore;
+          // Prefer `has_more_continue` when this iteration is chained because
+          // the previous poll capped at INBOX_POLL_LIMIT — distinguishes a
+          // backlog drain from a coalesced ws_inbox_update drain in logs.
+          currentTrigger = hasMore ? "has_more_continue" : "coalesced_inbox_update";
+        } while ((pendingUpdate || hasMore) && running);
       } catch (err) {
         log.error("botcord inbox drain failed", { err: String(err) });
       } finally {

package/src/gateway/dispatcher.ts

@@ -324,6 +324,18 @@ export class Dispatcher {
     // grounded turnId for any downstream attention_skipped / dropped / etc.
     this.emitInbound(turnId, msg);
 
+    this.log.info("dispatcher: inbound received", {
+      agentId: msg.accountId,
+      roomId: msg.conversation.id,
+      topicId: msg.conversation.threadId ?? null,
+      turnId,
+      messageId: msg.id,
+      senderId: msg.sender.id,
+      senderKind: msg.sender.kind,
+      mode,
+      textPreview: logPreview(rawText),
+    });
+
     // Notify the optional observer (activity tracking, metrics, etc.) as soon
     // as the dispatcher owns the message. Errors must not abort the turn.
     if (this.onInbound) {
@@ -448,7 +460,14 @@ export class Dispatcher {
     const myGen = q.cancelGen;
     const prev = q.current;
     if (prev) {
-      this.log.info("dispatcher: cancelling previous turn", { queueKey });
+      this.log.info("dispatcher: cancelling previous turn", {
+        agentId: msg.accountId,
+        roomId: msg.conversation.id,
+        topicId: msg.conversation.threadId ?? null,
+        turnId,
+        prevTurnId: prev.turnId,
+        queueKey,
+      });
       // Record the supersede BEFORE aborting so the prev turn's finalize sees
       // the abort reason (TurnSupersededError) and skips writing turn_error.
       this.transcript.write({
@@ -469,7 +488,13 @@ export class Dispatcher {
     // already fired its own abort + runTurn, or be mid-await itself. If so,
     // drop out silently — the newest turn is the only one that should run.
     if (myGen !== q.cancelGen) {
-      this.log.info("dispatcher: cancel-previous superseded", { queueKey });
+      this.log.info("dispatcher: cancel-previous superseded", {
+        agentId: msg.accountId,
+        roomId: msg.conversation.id,
+        topicId: msg.conversation.threadId ?? null,
+        turnId,
+        queueKey,
+      });
       // We didn't run the turn; emit dropped so the caller's inbound has a
       // matching path record. supersededBy is unknown at this layer (newer
       // arrival owns its own bump) — leave null.
@@ -738,10 +763,25 @@ export class Dispatcher {
       this.transcript.write(dispatched);
     }
 
+    this.log.info("dispatcher: dispatched to runtime", {
+      agentId: msg.accountId,
+      roomId: msg.conversation.id,
+      topicId: msg.conversation.threadId ?? null,
+      turnId,
+      runtime: route.runtime,
+      cwd: route.cwd,
+      ...(mergedFromTurnIds.length > 0 ? { mergedFromTurns: mergedFromTurnIds.length } : {}),
+      composedPreview: logPreview(text),
+    });
+
     // Hard-cap turn with a timeout.
     const timer = setTimeout(() => {
       slot.timedOut = true;
       this.log.warn("dispatcher: turn timed out", {
+        agentId: msg.accountId,
+        roomId: msg.conversation.id,
+        topicId: msg.conversation.threadId ?? null,
+        turnId,
         queueKey,
         timeoutMs: this.turnTimeoutMs,
       });
@@ -1072,11 +1112,14 @@ export class Dispatcher {
             text: `⚠️ Runtime timeout after ${Math.round(this.turnTimeoutMs / 60000)} minute(s); aborted`,
             replyTo: msg.id,
             traceId: msg.trace?.id ?? null,
-          });
+          }, turnId);
         } else {
           this.log.warn("dispatcher: timeout in non-owner-chat room — error reply suppressed", {
+            agentId: msg.accountId,
+            roomId: msg.conversation.id,
+            topicId: msg.conversation.threadId ?? null,
+            turnId,
             queueKey,
-            conversationId: msg.conversation.id,
             timeoutMs: this.turnTimeoutMs,
           });
         }
@@ -1086,6 +1129,10 @@ export class Dispatcher {
       if (threw) {
         const errMsg = threw instanceof Error ? threw.message : String(threw);
         this.log.error("dispatcher: runtime threw", {
+          agentId: msg.accountId,
+          roomId: msg.conversation.id,
+          topicId: msg.conversation.threadId ?? null,
+          turnId,
           queueKey,
           runtime: route.runtime,
           error: errMsg,
@@ -1110,11 +1157,14 @@ export class Dispatcher {
             text: `⚠️ Runtime error: ${truncate(errMsg, 500)}`,
             replyTo: msg.id,
             traceId: msg.trace?.id ?? null,
-          });
+          }, turnId);
         } else {
           this.log.warn("dispatcher: runtime error in non-owner-chat room — error reply suppressed", {
+            agentId: msg.accountId,
+            roomId: msg.conversation.id,
+            topicId: msg.conversation.threadId ?? null,
+            turnId,
             queueKey,
-            conversationId: msg.conversation.id,
           });
         }
         return;
@@ -1201,8 +1251,11 @@ export class Dispatcher {
         this.log.debug(
           "dispatcher: non-owner-chat — discarding result.text (agent must use botcord_send)",
           {
+            agentId: msg.accountId,
+            roomId: msg.conversation.id,
+            topicId: msg.conversation.threadId ?? null,
+            turnId,
             queueKey,
-            conversationId: msg.conversation.id,
             replyTextLen: replyText.length,
           },
         );
@@ -1236,7 +1289,7 @@ export class Dispatcher {
         text: replyText,
         replyTo: msg.id,
         traceId: msg.trace?.id ?? null,
-      });
+      }, turnId);
       this.emitOutbound({
         turnId,
         msg,
@@ -1268,14 +1321,18 @@ export class Dispatcher {
   private async sendReply(
     channel: ChannelAdapter,
     outbound: GatewayOutboundMessage,
+    turnId?: string,
   ): Promise<{ ok: true } | { ok: false; error: string }> {
     try {
       await channel.send({ message: outbound, log: this.log });
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
       this.log.warn("dispatcher: channel.send failed", {
+        agentId: outbound.accountId,
+        roomId: outbound.conversationId,
+        topicId: outbound.threadId ?? null,
+        ...(turnId ? { turnId } : {}),
         channel: outbound.channel,
-        conversationId: outbound.conversationId,
         error,
       });
       return { ok: false, error };
@@ -1285,7 +1342,10 @@ export class Dispatcher {
         await this.onOutbound(outbound);
       } catch (err) {
         this.log.warn("dispatcher: onOutbound threw — continuing", {
-          conversationId: outbound.conversationId,
+          agentId: outbound.accountId,
+          roomId: outbound.conversationId,
+          topicId: outbound.threadId ?? null,
+          ...(turnId ? { turnId } : {}),
           error: err instanceof Error ? err.message : String(err),
         });
       }
@@ -1333,6 +1393,19 @@ export class Dispatcher {
     deliveryReason: string | null;
     blocks: TranscriptBlockSummary[];
   }): void {
+    const durationMs = Date.now() - args.startedAt;
+    this.log.info("dispatcher: outbound emitted", {
+      agentId: args.msg.accountId,
+      roomId: args.msg.conversation.id,
+      topicId: args.msg.conversation.threadId ?? null,
+      turnId: args.turnId,
+      runtime: args.runtime,
+      deliveryStatus: args.deliveryStatus,
+      ...(args.deliveryReason ? { deliveryReason: args.deliveryReason } : {}),
+      durationMs,
+      replyPreview: logPreview(args.finalText.text),
+      ...(typeof args.costUsd === "number" ? { costUsd: args.costUsd } : {}),
+    });
     if (!this.transcript.enabled) return;
     const rec: import("./transcript.js").OutboundTranscriptRecord = {
       ts: nowIso(),
@@ -1343,7 +1416,7 @@ export class Dispatcher {
       topicId: args.msg.conversation.threadId ?? null,
       runtime: args.runtime,
       runtimeSessionId: args.runtimeSessionId,
-      durationMs: Date.now() - args.startedAt,
+      durationMs,
       finalText: args.finalText.text,
       deliveryStatus: args.deliveryStatus,
       deliveryReason: args.deliveryReason,
@@ -1397,3 +1470,13 @@ function resolveQueueMode(
 function truncate(s: string, max: number): string {
   return s.length <= max ? s : s.slice(0, max) + "…";
 }
+
+/**
+ * Single-line preview of a multi-line user/agent text, capped at `max` chars.
+ * Used to embed message/reply previews in daemon.log lines without bloating
+ * each line into multi-line JSON. Full text lives in transcripts.
+ */
+function logPreview(s: string, max: number = 120): string {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length <= max ? flat : flat.slice(0, max) + "…";
+}