@botcord/daemon 0.2.62 → 0.2.64

package/dist/gateway/dispatcher.js

@@ -10,6 +10,8 @@ const DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1000;
  * (or `botcord send` CLI via Bash) to actually deliver replies.
  */
 const OWNER_CHAT_ROOM_PREFIX = "rm_oc_";
+const TRANSCRIPT_BLOCK_RAW_LIMIT = 16 * 1024;
+const SECRET_KEY_RE = /token|secret|private.?key|api.?key|authorization|password/i;
 /** Maximum number of buffered serial entries per queue. Excess entries drop oldest. */
 const MAX_BATCH_BUFFER_ENTRIES = 40;
 /**
@@ -33,6 +35,60 @@ const TYPING_DEBOUNCE_MS = 2000;
 const TYPING_REFRESH_MS = 4000;
 /** LRU cap on the typing-recency map so long-running daemons don't grow unbounded. */
 const TYPING_RECENCY_CAP = 1024;
+function transcriptBlocksVerbose() {
+    return process.env.BOTCORD_TRANSCRIPT_BLOCKS === "verbose" ||
+        process.env.BOTCORD_TRACE_VERBOSE === "1";
+}
+function summarizeStreamBlock(block) {
+    const summary = { type: block.kind };
+    const raw = block.raw;
+    if (raw && typeof raw === "object") {
+        if (typeof raw.text === "string")
+            summary.chars = raw.text.length;
+        if (typeof raw.name === "string")
+            summary.name = raw.name;
+        const update = raw.params?.update ?? raw.update;
+        if (update && typeof update === "object") {
+            const u = update;
+            if (typeof u.sessionUpdate === "string" && !summary.name)
+                summary.name = u.sessionUpdate;
+            const toolCall = u.toolCall;
+            if (toolCall && typeof toolCall === "object") {
+                const toolName = toolCall.name;
+                if (typeof toolName === "string")
+                    summary.name = toolName;
+            }
+        }
+    }
+    return summary;
+}
+function redactAndCap(value, budget = TRANSCRIPT_BLOCK_RAW_LIMIT) {
+    const seen = new WeakSet();
+    const walk = (v) => {
+        if (typeof v === "string") {
+            return redactSecretString(v.length > budget ? `${v.slice(0, budget)}…` : v);
+        }
+        if (Array.isArray(v))
+            return v.slice(0, 50).map(walk);
+        if (!v || typeof v !== "object")
+            return v;
+        if (seen.has(v))
+            return "[Circular]";
+        seen.add(v);
+        const out = {};
+        for (const [key, child] of Object.entries(v).slice(0, 80)) {
+            out[key] = SECRET_KEY_RE.test(key) ? "[REDACTED]" : walk(child);
+        }
+        return out;
+    };
+    return walk(value);
+}
+function redactSecretString(value) {
+    return value
+        .replace(/(Authorization:\s*Bearer\s+)[^\s"']+/gi, "$1[REDACTED]")
+        .replace(/\b(token=)[^\s"']+/gi, "$1[REDACTED]")
+        .replace(/\b(drt_|dit_|gho_)[A-Za-z0-9_-]+/g, "$1[REDACTED]");
+}
 /**
  * Reason carried on `AbortController.abort()` when a cancel-previous wave
  * is taking over the slot. Distinguishing this from a timeout abort lets
@@ -701,15 +757,23 @@ export class Dispatcher {
             (streamable || !isBotCordChannel(channel));
         const canStream = streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
         const recordBlock = (block) => {
-            const summary = { type: block.kind };
-            const raw = block.raw;
-            if (raw && typeof raw === "object") {
-                if (typeof raw.text === "string")
-                    summary.chars = raw.text.length;
-                if (typeof raw.name === "string")
-                    summary.name = raw.name;
-            }
+            const summary = summarizeStreamBlock(block);
             slot.blocks.push(summary);
+            if (this.transcript.enabled) {
+                this.transcript.write({
+                    ts: new Date().toISOString(),
+                    kind: "block",
+                    turnId,
+                    agentId: msg.accountId,
+                    roomId: msg.conversation.id,
+                    topicId: msg.conversation.threadId ?? null,
+                    runtime: route.runtime,
+                    seq: block.seq,
+                    blockType: block.kind,
+                    summary,
+                    ...(transcriptBlocksVerbose() ? { raw: redactAndCap(block.raw) } : {}),
+                });
+            }
         };
         // Owner-chat lifecycle state for typing/thinking. The dispatcher is the
         // only component that sees turn boundaries + channel capabilities + trace
@@ -877,7 +941,7 @@ export class Dispatcher {
                 sendThinkingMarker(event.phase, event.label, "runtime");
             }
             : undefined;
-        const onBlock = canStream
+        const onBlock = (canStream || this.transcript.enabled)
             ? (block) => {
                 // Always record adapter-emitted blocks for transcript fidelity, even
                 // after abort — the transcript reflects what the runtime emitted,
@@ -885,6 +949,8 @@ export class Dispatcher {
                 recordBlock(block);
                 if (controller.signal.aborted)
                     return;
+                if (!canStream)
+                    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
@@ -904,7 +970,7 @@ export class Dispatcher {
                     thinkingActive = false;
                     sawAssistantText = true;
                 }
-                forwardBlockToChannel(block);
+                forwardBlockToChannel?.(block);
             }
             : undefined;
         // Helper used by terminal paths (success / timeout / error) to ensure

package/dist/gateway/gateway.d.ts

@@ -58,7 +58,8 @@ export interface GatewayBootOptions {
      * Tri-state convenience: if `transcript` is not provided, the gateway
      * constructs a writer using this flag plus `transcriptRootDir`. Use
      * {@link resolveTranscriptEnabled} to combine `BOTCORD_TRANSCRIPT` env with
-     * the persistent daemon-config flag.
+     * the persistent daemon-config flag. When omitted, transcripts are enabled
+     * by default.
      */
     transcriptEnabled?: boolean;
     /** Root directory for transcript files. Defaults to `~/.botcord/agents`. */

package/dist/gateway/gateway.js

@@ -57,7 +57,7 @@ export class Gateway {
         const transcript = opts.transcript
             ?? createTranscriptWriter({
                 log: this.log,
-                enabled: opts.transcriptEnabled === true,
+                enabled: opts.transcriptEnabled,
                 rootDir: opts.transcriptRootDir,
             });
         this.dispatcher = new Dispatcher({

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

@@ -109,6 +109,12 @@ export class OpenclawAcpAdapter {
             // synthetic test calls).
             conversationKey: stringField(opts.context, "conversationKey") ?? "default",
         });
+        const traceContext = {
+            turnId: stringField(opts.context, "turnId"),
+            messageId: stringField(opts.context, "messageId"),
+            roomId: stringField(opts.context, "roomId"),
+            topicId: nullableStringField(opts.context, "topicId"),
+        };
         const key = poolKey(opts.accountId, gateway.name);
         let handle;
         try {
@@ -199,7 +205,17 @@ export class OpenclawAcpAdapter {
                     throw new Error(`newSession failed: ${err.message}`);
                 }
             }
-            handle.subscribers.set(acpSessionId, onNotification);
+            handle.subscribers.set(acpSessionId, { notify: onNotification, traceContext });
+            handle.trace?.write({
+                stream: "turn_context",
+                ...traceContext,
+                params: {
+                    sessionId: acpSessionId,
+                    sessionKey,
+                    openclawAgent,
+                    cwd: opts.cwd,
+                },
+            });
             if (opts.signal?.aborted) {
                 return failResult(acpSessionId, "openclaw-acp: aborted before prompt");
             }
@@ -232,7 +248,18 @@ export class OpenclawAcpAdapter {
                         });
                         handle.subscribers.delete(acpSessionId);
                         acpSessionId = fresh;
-                        handle.subscribers.set(acpSessionId, onNotification);
+                        handle.subscribers.set(acpSessionId, { notify: onNotification, traceContext });
+                        handle.trace?.write({
+                            stream: "turn_context",
+                            ...traceContext,
+                            params: {
+                                sessionId: acpSessionId,
+                                sessionKey,
+                                openclawAgent,
+                                cwd: opts.cwd,
+                                recreatedFrom: oldSessionId,
+                            },
+                        });
                         log.info("openclaw-acp.session-recreated", {
                             accountId: opts.accountId,
                             oldSessionId,
@@ -525,19 +552,20 @@ function routeMessage(handle, msg) {
     }
     // Notification.
     if (msg?.method && msg?.params) {
+        const sid = msg.params?.sessionId;
+        const sub = typeof sid === "string" ? handle.subscribers.get(sid) : undefined;
         handle.trace?.write({
             stream: "rpc_in",
             direction: "in",
             method: msg.method,
             status: "notification",
+            ...(sub?.traceContext ?? {}),
             params: msg.params,
         });
-        const sid = msg.params?.sessionId;
         if (typeof sid === "string") {
-            const sub = handle.subscribers.get(sid);
             if (sub) {
                 try {
-                    sub({ method: msg.method, params: msg.params });
+                    sub.notify({ method: msg.method, params: msg.params });
                 }
                 catch (err) {
                     log.warn("openclaw-acp.subscriber-threw", {
@@ -913,6 +941,14 @@ function stringField(bag, key) {
     const v = bag[key];
     return typeof v === "string" && v.length > 0 ? v : undefined;
 }
+function nullableStringField(bag, key) {
+    if (!bag)
+        return undefined;
+    const v = bag[key];
+    if (v === null)
+        return null;
+    return typeof v === "string" && v.length > 0 ? v : undefined;
+}
 /**
  * Build the OpenClaw ACP `sessionKey` for a daemon turn. `accountId` is
  * always included to prevent two daemon agents from colliding on the same

package/dist/gateway/transcript.d.ts

@@ -6,9 +6,13 @@ import type { GatewayLogger } from "./log.js";
 export declare const TRANSCRIPT_TEXT_LIMIT: number;
 /** Soft cap on a single transcript file before rotation. */
 export declare const TRANSCRIPT_FILE_LIMIT: number;
+/** Default retention window for transcript JSONL files. */
+export declare const TRANSCRIPT_RETENTION_MS: number;
+/** Minimum interval between background transcript retention sweeps. */
+export declare const TRANSCRIPT_CLEANUP_INTERVAL_MS: number;
 /** Default root directory for per-agent transcript trees. */
 export declare function defaultTranscriptRoot(): string;
-export type TranscriptRecordKind = "inbound" | "dispatched" | "compose_failed" | "outbound" | "turn_error" | "attention_skipped" | "dropped";
+export type TranscriptRecordKind = "inbound" | "dispatched" | "block" | "compose_failed" | "outbound" | "turn_error" | "attention_skipped" | "dropped";
 export interface TranscriptRecordBase {
     ts: string;
     kind: TranscriptRecordKind;
@@ -45,6 +49,14 @@ export interface DispatchedTranscriptRecord extends TranscriptRecordBase {
         composedText?: true;
     };
 }
+export interface BlockTranscriptRecord extends TranscriptRecordBase {
+    kind: "block";
+    runtime: string;
+    seq: number;
+    blockType: string;
+    summary: TranscriptBlockSummary;
+    raw?: unknown;
+}
 export interface ComposeFailedTranscriptRecord extends TranscriptRecordBase {
     kind: "compose_failed";
     error: string;
@@ -86,7 +98,7 @@ export interface DroppedTranscriptRecord extends TranscriptRecordBase {
     reason: DroppedReason;
     supersededBy?: string | null;
 }
-export type TranscriptRecord = InboundTranscriptRecord | DispatchedTranscriptRecord | ComposeFailedTranscriptRecord | OutboundTranscriptRecord | TurnErrorTranscriptRecord | AttentionSkippedTranscriptRecord | DroppedTranscriptRecord;
+export type TranscriptRecord = InboundTranscriptRecord | DispatchedTranscriptRecord | BlockTranscriptRecord | ComposeFailedTranscriptRecord | OutboundTranscriptRecord | TurnErrorTranscriptRecord | AttentionSkippedTranscriptRecord | DroppedTranscriptRecord;
 /**
  * Truncate `value` to TRANSCRIPT_TEXT_LIMIT chars. Returns the (possibly
  * truncated) text and whether truncation occurred. Surrogate-pair aware: if
@@ -108,10 +120,14 @@ export interface CreateTranscriptWriterOptions {
     /** Defaults to `~/.botcord/agents`. */
     rootDir?: string;
     log: GatewayLogger;
-    /** Defaults to `false` — see design §6 (default-off). */
+    /** Defaults to `true`; pass `false` to disable persistence. */
     enabled?: boolean;
     /** Override file rotation threshold (bytes). Defaults to TRANSCRIPT_FILE_LIMIT. */
     maxFileBytes?: number;
+    /** Delete transcript JSONL files older than this. Defaults to 3 days. */
+    retentionMs?: number;
+    /** Minimum interval between retention sweeps. Defaults to 6 hours. */
+    cleanupIntervalMs?: number;
 }
 export declare function createTranscriptWriter(opts: CreateTranscriptWriterOptions): TranscriptWriter;
 /**
@@ -120,4 +136,5 @@ export declare function createTranscriptWriter(opts: CreateTranscriptWriterOptio
  *  - env === "0" → false (force off)
  *  - any other / unset → fall back to `configEnabled`
  */
-export declare function resolveTranscriptEnabled(envVal: string | undefined, configEnabled: boolean): boolean;
+export declare function resolveTranscriptEnabled(envVal: string | undefined, configEnabled: boolean | undefined): boolean;
+export declare function cleanupTranscriptFiles(rootDir: string, cutoffMs: number): number;

package/dist/gateway/transcript.js

@@ -1,4 +1,4 @@
-import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { appendFileSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { transcriptFilePath } from "./transcript-paths.js";
@@ -9,6 +9,10 @@ import { transcriptFilePath } from "./transcript-paths.js";
 export const TRANSCRIPT_TEXT_LIMIT = 32 * 1024;
 /** Soft cap on a single transcript file before rotation. */
 export const TRANSCRIPT_FILE_LIMIT = 8 * 1024 * 1024;
+/** Default retention window for transcript JSONL files. */
+export const TRANSCRIPT_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+/** Minimum interval between background transcript retention sweeps. */
+export const TRANSCRIPT_CLEANUP_INTERVAL_MS = 6 * 60 * 60 * 1000;
 /** Default root directory for per-agent transcript trees. */
 export function defaultTranscriptRoot() {
     return path.join(homedir(), ".botcord", "agents");
@@ -45,15 +49,21 @@ class FsTranscriptWriter {
     rootDir;
     log;
     maxFileBytes;
+    retentionMs;
+    cleanupIntervalMs;
     fileMeta = new Map();
     firstWriteAnnounced = false;
-    constructor(rootDir, log, maxFileBytes) {
+    lastCleanupAt = 0;
+    constructor(rootDir, log, maxFileBytes, retentionMs, cleanupIntervalMs) {
         this.rootDir = rootDir;
         this.log = log;
         this.maxFileBytes = maxFileBytes;
+        this.retentionMs = retentionMs;
+        this.cleanupIntervalMs = cleanupIntervalMs;
     }
     write(rec) {
         try {
+            this.cleanupOldFiles();
             const file = transcriptFilePath(this.rootDir, rec.agentId, rec.roomId, rec.topicId);
             const dir = path.dirname(file);
             try {
@@ -118,14 +128,29 @@ class FsTranscriptWriter {
             });
         }
     }
+    cleanupOldFiles() {
+        const now = Date.now();
+        if (now - this.lastCleanupAt < this.cleanupIntervalMs)
+            return;
+        this.lastCleanupAt = now;
+        const cutoff = now - this.retentionMs;
+        const removed = cleanupTranscriptFiles(this.rootDir, cutoff);
+        if (removed > 0) {
+            this.log.info("transcript cleanup removed old files", {
+                dir: this.rootDir,
+                removed,
+                retentionMs: this.retentionMs,
+            });
+        }
+    }
 }
 export function createTranscriptWriter(opts) {
     const rootDir = opts.rootDir ?? defaultTranscriptRoot();
-    const enabled = opts.enabled ?? false;
+    const enabled = opts.enabled ?? true;
     if (!enabled)
         return new NoopTranscriptWriter(rootDir);
     const maxBytes = opts.maxFileBytes ?? TRANSCRIPT_FILE_LIMIT;
-    return new FsTranscriptWriter(rootDir, opts.log, maxBytes);
+    return new FsTranscriptWriter(rootDir, opts.log, maxBytes, opts.retentionMs ?? TRANSCRIPT_RETENTION_MS, opts.cleanupIntervalMs ?? TRANSCRIPT_CLEANUP_INTERVAL_MS);
 }
 /**
  * Resolve the tri-state enable flag (env wins; otherwise config). See design §5.
@@ -138,7 +163,43 @@ export function resolveTranscriptEnabled(envVal, configEnabled) {
         return true;
     if (envVal === "0")
         return false;
-    return configEnabled;
+    return configEnabled ?? true;
+}
+export function cleanupTranscriptFiles(rootDir, cutoffMs) {
+    let removed = 0;
+    const visit = (dir, depth) => {
+        if (depth < 0)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const file = path.join(dir, entry);
+            try {
+                const st = statSync(file);
+                if (st.isDirectory()) {
+                    visit(file, depth - 1);
+                    continue;
+                }
+                if (st.isFile() &&
+                    entry.endsWith(".jsonl") &&
+                    file.includes(`${path.sep}transcripts${path.sep}`) &&
+                    st.mtimeMs < cutoffMs) {
+                    rmSync(file, { force: true });
+                    removed += 1;
+                }
+            }
+            catch {
+                // ignore disappearing files and permission errors
+            }
+        }
+    };
+    visit(rootDir, 6);
+    return removed;
 }
 function formatStamp(d) {
     const pad = (n) => n.toString().padStart(2, "0");

package/dist/index.js

@@ -770,16 +770,18 @@ function cmdTranscriptStatus() {
         if (e.code !== CONFIG_MISSING)
             throw err;
     }
-    const configEnabled = cfg?.transcript?.enabled === true;
+    const configEnabled = cfg?.transcript?.enabled;
     const env = process.env.BOTCORD_TRANSCRIPT;
     const effective = resolveTranscriptEnabled(env, configEnabled);
     let source;
     if (env === "1" || env === "0")
         source = `env BOTCORD_TRANSCRIPT=${env}`;
-    else if (configEnabled)
+    else if (configEnabled === true)
         source = "config (transcript.enabled=true)";
+    else if (configEnabled === false)
+        source = "config (transcript.enabled=false)";
     else
-        source = "default-off";
+        source = "default-on";
     console.log(`enabled: ${effective}`);
     console.log(`source: ${source}`);
     console.log(`root: ${defaultTranscriptRoot()}`);
@@ -826,9 +828,9 @@ function cmdTranscriptTail(args) {
         catch {
             // ignore — config may simply not exist yet
         }
-        const enabled = resolveTranscriptEnabled(process.env.BOTCORD_TRANSCRIPT, cfg?.transcript?.enabled === true);
+        const enabled = resolveTranscriptEnabled(process.env.BOTCORD_TRANSCRIPT, cfg?.transcript?.enabled);
         if (!enabled) {
-            console.error("hint: transcripts are disabled (default-off). Run `botcord-daemon transcript enable` and restart the daemon, then send a new message.");
+            console.error("hint: transcripts are disabled. Run `botcord-daemon transcript enable` and restart the daemon, then send a new message.");
         }
         process.exit(1);
     }

package/package.json

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

package/src/__tests__/control-channel.test.ts

@@ -322,6 +322,43 @@ describe("ControlChannel — REVOKE frame (plan §6.3)", () => {
   });
 });
 
+describe("ControlChannel — reconnect scheduling", () => {
+  beforeEach(() => {
+    FakeWebSocket.instances.length = 0;
+  });
+
+  it("adds jitter and coalesces duplicate close events into one reconnect", async () => {
+    const randomSpy = vi.spyOn(Math, "random").mockReturnValue(1);
+    const auth = new UserAuthManager({
+      record: makeAuthRecord(),
+      file: "/tmp/never-written-user-auth.json",
+    });
+    const ctor = makeFakeCtor();
+    const ch = new ControlChannel({
+      auth,
+      handle: () => ({ ok: true }),
+      webSocketCtor: ctor as unknown as typeof import("ws").default,
+      hubPublicKey: null,
+      backoffMs: [25],
+    });
+    await ch.start();
+    const ws = FakeWebSocket.instances[0];
+
+    ws.emit("close", 1012, Buffer.from(""));
+    ws.emit("close", 1012, Buffer.from(""));
+
+    // Base delay is 25ms; with random=1 and 25% jitter the actual delay is
+    // 31ms. Duplicate close events should still leave only one timer queued.
+    await new Promise((r) => setTimeout(r, 20));
+    expect(FakeWebSocket.instances).toHaveLength(1);
+    await new Promise((r) => setTimeout(r, 20));
+    expect(FakeWebSocket.instances).toHaveLength(2);
+
+    randomSpy.mockRestore();
+    await ch.stop();
+  });
+});
+
 afterEach(() => {
   FakeWebSocket.instances.length = 0;
 });

package/src/__tests__/diagnostics.test.ts

@@ -11,16 +11,22 @@ describe("diagnostics bundle", () => {
     const logFile = path.join(tmp, "daemon.log");
     const configFile = path.join(tmp, "config.json");
     const snapshotFile = path.join(tmp, "snapshot.json");
+    const sessionsFile = path.join(tmp, "sessions.json");
     const diagnosticsDir = path.join(tmp, "diagnostics");
     writeFileSync(logFile, 'Authorization: Bearer secret-token\n{"refreshToken":"drt_secret"}\n');
     writeFileSync(configFile, '{"token":"agent-secret","ok":true}\n');
     writeFileSync(snapshotFile, '{"version":1}\n');
+    writeFileSync(
+      sessionsFile,
+      '{"version":1,"entries":{"k":{"runtimeSessionId":"sess_1","token":"session-secret"}}}\n',
+    );
 
     const bundle = await createDiagnosticBundle({
       diagnosticsDir,
       logFile,
       configFile,
       snapshotFile,
+      sessionsFile,
       doctor: { text: "doctor ok", json: { ok: true } },
     });
     expect(bundle.filename).toMatch(/^botcord-daemon-diagnostics-.*\.zip$/);
@@ -42,12 +48,29 @@ describe("diagnostics bundle", () => {
     expect(listing).toContain("doctor.json");
     expect(listing).toContain("status.json");
     expect(listing).toContain("config.json.redacted");
+    expect(listing).toContain("sessions.json.redacted");
 
     const log = execFileSync("unzip", ["-p", bundle.path, "daemon.log"], {
       encoding: "utf8",
     });
     expect(log).toContain("Authorization: Bearer [REDACTED]");
     expect(log).toContain('"refreshToken":"[REDACTED]"');
+
+    const status = JSON.parse(execFileSync("unzip", ["-p", bundle.path, "status.json"], {
+      encoding: "utf8",
+    }));
+    expect(status.daemon.packageName).toBe("@botcord/daemon");
+    expect(status.daemon.version).toMatch(/^\d+\.\d+\.\d+/);
+    expect(status.daemon.entrypoint).toBeTruthy();
+    expect(status.daemon.packages["@botcord/daemon"]).toBe(status.daemon.version);
+    expect(status.environment.PATH).toBeTruthy();
+    expect(status.sessionsPath).toBe(sessionsFile);
+
+    const sessions = execFileSync("unzip", ["-p", bundle.path, "sessions.json.redacted"], {
+      encoding: "utf8",
+    });
+    expect(sessions).toContain('"runtimeSessionId":"sess_1"');
+    expect(sessions).toContain('"token":"[REDACTED]"');
   }, 20_000);
 
   it("bundles active log plus latest 5 rotated logs by default, or all with includeAllLogs", async () => {

package/src/acp-logs.ts

@@ -20,6 +20,7 @@ export type AcpTraceStream =
   | "child_error"
   | "stderr"
   | "stdout_non_json"
+  | "turn_context"
   | "rpc_in"
   | "rpc_out";
 
@@ -37,6 +38,10 @@ export interface AcpTraceMeta {
 
 export interface AcpTraceEvent {
   stream: AcpTraceStream;
+  turnId?: string;
+  messageId?: string;
+  roomId?: string;
+  topicId?: string | null;
   direction?: "in" | "out";
   pid?: number;
   id?: number | string;
@@ -132,9 +137,10 @@ function writeAcpTrace(
       ts: new Date().toISOString(),
       runtime: meta.runtime,
       accountId: meta.accountId,
-      turnId: meta.turnId,
-      roomId: meta.roomId,
-      topicId: meta.topicId ?? undefined,
+      turnId: event.turnId ?? meta.turnId,
+      messageId: event.messageId,
+      roomId: event.roomId ?? meta.roomId,
+      topicId: event.topicId ?? meta.topicId ?? undefined,
       gatewayName: meta.gatewayName,
       gatewayUrl: meta.gatewayUrl,
       hermesProfile: meta.hermesProfile,

package/src/config.ts

@@ -159,7 +159,7 @@ export interface DaemonConfig {
   streamBlocks: boolean;
   /**
    * Persistent transcript-logging settings (design §3 / §6). Defaults to
-   * disabled — see `BOTCORD_TRANSCRIPT` for env-driven temporary overrides.
+   * enabled — see `BOTCORD_TRANSCRIPT` for env-driven temporary overrides.
    */
   transcript?: TranscriptConfig;
 
@@ -186,8 +186,8 @@ export interface DaemonConfig {
 }
 
 /**
- * Persistent transcript settings (design §6). Default-off — `botcord-daemon
- * transcript enable` flips `enabled` and `transcript disable` flips it back.
+ * Persistent transcript settings (design §6). Default-on — `botcord-daemon
+ * transcript disable` sets `enabled=false`, and `transcript enable` flips it back.
  * The env var `BOTCORD_TRANSCRIPT` can override at boot.
  */
 export interface TranscriptConfig {