@botcord/daemon 0.2.63 → 0.2.65

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/dist/turn-text.js

@@ -33,7 +33,8 @@ function readEnvelopeType(raw) {
 }
 function isThirdPartyConversation(conversationId) {
     return (conversationId.startsWith("telegram:") ||
-        conversationId.startsWith("wechat:"));
+        conversationId.startsWith("wechat:") ||
+        conversationId.startsWith("feishu:"));
 }
 function replyDeliveryHint(msg) {
     return isThirdPartyConversation(msg.conversation.id)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.63",
+  "version": "0.2.65",
   "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__/turn-text.test.ts

@@ -134,6 +134,22 @@ describe("composeBotCordUserTurn", () => {
     expect(out).not.toContain("botcord_send");
   });
 
+  it("does not tell Feishu chats to use botcord_send", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        channel: "gw_feishu_123",
+        conversation: { id: "feishu:user:oc_alice", kind: "direct" },
+        sender: { id: "feishu:user:ou_alice", name: "Alice", kind: "user" },
+      }),
+    );
+    expect(out).toContain("third-party gateway chat");
+    expect(out).toContain("Reply normally in your final assistant message");
+    expect(out).toContain("conversation_id: feishu:user:oc_alice");
+    expect(out).toContain("channel: gw_feishu_123");
+    expect(out).not.toContain("Plain text output WILL NOT be sent");
+    expect(out).not.toContain("botcord_send");
+  });
+
   it("passes owner-chat messages through verbatim (no wrapper, no hint)", () => {
     const out = composeBotCordUserTurn(
       makeMessage({

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 {

package/src/control-channel.ts

@@ -25,6 +25,7 @@ import {
 
 /** Exponential backoff plan for transient disconnects. */
 const RECONNECT_BACKOFF_MS = [1000, 2000, 4000, 8000, 16000, 30000];
+const RECONNECT_JITTER_RATIO = 0.25;
 /**
  * Keepalive cadence. Has to stay below the smallest idle-timeout in any
  * intermediary on the daemon → Hub WS path. Cloudflare and AWS ALB both
@@ -55,6 +56,11 @@ export function controlSigningInput(
   return jcsCanonicalize(obj) ?? "{}";
 }
 
+function withReconnectJitter(delayMs: number): { delayMs: number; jitterMs: number } {
+  const jitterMs = Math.floor(Math.random() * delayMs * RECONNECT_JITTER_RATIO);
+  return { delayMs: delayMs + jitterMs, jitterMs };
+}
+
 /** Handler invoked for each inbound frame. Return value is the ack payload. */
 export type ControlFrameHandler = (
   frame: ControlFrame,
@@ -110,6 +116,7 @@ export class ControlChannel {
   private readonly seenFrameIds: string[] = [];
   private connectInflight: Promise<void> | null = null;
   private connected = false;
+  private connectionSeq = 0;
 
   constructor(opts: ControlChannelOptions) {
     this.auth = opts.auth;
@@ -220,6 +227,20 @@ export class ControlChannel {
   private async connect(): Promise<void> {
     const record = this.auth.current;
     if (!record) throw new Error("control-channel: no user-auth");
+    const current = this.ws;
+    if (
+      current &&
+      (current.readyState === WebSocket.CONNECTING || current.readyState === WebSocket.OPEN)
+    ) {
+      daemonLog.debug("control-channel connect skipped (socket already active)", {
+        readyState: current.readyState,
+      });
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
 
     const accessToken = await this.auth.ensureAccessToken();
     const url = buildDaemonWebSocketUrl(
@@ -229,6 +250,7 @@ export class ControlChannel {
     );
     daemonLog.info("control-channel connecting", { url });
 
+    const connectionId = ++this.connectionSeq;
     const ws = new this.webSocketCtor(url, {
       headers: { Authorization: `Bearer ${accessToken}` },
     });
@@ -237,6 +259,15 @@ export class ControlChannel {
     await new Promise<void>((resolve, reject) => {
       const onOpen = (): void => {
         ws.removeListener("error", onError);
+        if (this.stopRequested || this.ws !== ws || connectionId !== this.connectionSeq) {
+          try {
+            ws.close(1000, "stale control-channel connection");
+          } catch {
+            // ignore
+          }
+          resolve();
+          return;
+        }
         this.connected = true;
         this.reconnectAttempts = 0;
         daemonLog.info("control-channel connected", { url });
@@ -245,14 +276,21 @@ export class ControlChannel {
       };
       const onError = (err: Error): void => {
         ws.removeListener("open", onOpen);
+        if (this.ws !== ws || connectionId !== this.connectionSeq) {
+          resolve();
+          return;
+        }
         reject(err);
       };
       ws.once("open", onOpen);
       ws.once("error", onError);
     });
 
-    ws.on("message", (data) => this.onMessage(data));
-    ws.on("close", (code, reason) => this.onClose(code, reason));
+    ws.on("message", (data) => {
+      if (this.ws !== ws || connectionId !== this.connectionSeq) return;
+      void this.onMessage(data);
+    });
+    ws.on("close", (code, reason) => this.onClose(code, reason, ws, connectionId));
     ws.on("error", (err) =>
       daemonLog.warn("control-channel error", {
         error: err instanceof Error ? err.message : String(err),
@@ -292,8 +330,12 @@ export class ControlChannel {
     }
   }
 
-  private onClose(code: number, reason: Buffer): void {
+  private onClose(code: number, reason: Buffer, ws?: WebSocket, connectionId?: number): void {
     const reasonText = reason?.toString() || "";
+    if (ws && (this.ws !== ws || connectionId !== this.connectionSeq)) {
+      daemonLog.debug("control-channel stale close ignored", { code, reason: reasonText });
+      return;
+    }
     this.connected = false;
     this.stopKeepalive();
     this.ws = null;
@@ -314,6 +356,14 @@ export class ControlChannel {
 
   private scheduleReconnect(err?: unknown): void {
     if (this.stopRequested) return;
+    if (this.reconnectTimer) return;
+    const current = this.ws;
+    if (
+      current &&
+      (current.readyState === WebSocket.CONNECTING || current.readyState === WebSocket.OPEN)
+    ) {
+      return;
+    }
     if (err instanceof AuthRefreshRejectedError) {
       this.stopRequested = true;
       daemonLog.warn("control-channel: refresh rejected; halting reconnect (re-login required)", {
@@ -323,20 +373,23 @@ export class ControlChannel {
     }
     const attempt = this.reconnectAttempts;
     this.reconnectAttempts = attempt + 1;
-    const delay = this.backoff[Math.min(attempt, this.backoff.length - 1)];
+    const baseDelayMs = this.backoff[Math.min(attempt, this.backoff.length - 1)];
+    const { delayMs, jitterMs } = withReconnectJitter(baseDelayMs);
     if (err) {
       daemonLog.warn("control-channel reconnect scheduled", {
-        delayMs: delay,
+        delayMs,
+        baseDelayMs,
+        jitterMs,
         error: err instanceof Error ? err.message : String(err),
       });
     } else {
-      daemonLog.info("control-channel reconnect scheduled", { delayMs: delay });
+      daemonLog.info("control-channel reconnect scheduled", { delayMs, baseDelayMs, jitterMs });
     }
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       if (this.stopRequested) return;
       this.connect().catch((err) => this.scheduleReconnect(err));
-    }, delay);
+    }, delayMs);
   }
 
   private async onMessage(data: WebSocket.RawData): Promise<void> {

package/src/daemon.ts

@@ -518,7 +518,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     resolveHubUrl,
     transcriptEnabled: resolveTranscriptEnabled(
       process.env.BOTCORD_TRANSCRIPT,
-      opts.config.transcript?.enabled === true,
+      opts.config.transcript?.enabled,
     ),
   });