@botcord/daemon 0.2.61 → 0.2.62

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

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { createAcpTraceLogger } from "../../acp-logs.js";
 import { consoleLogger } from "../log.js";
 /**
  * Minimal bidirectional ACP (Agent Client Protocol) client used by runtime
@@ -22,22 +23,32 @@ const ASSISTANT_TEXT_CAP = 1 * 1024 * 1024;
 const KILL_GRACE_MS = 5_000;
 /** Deadline for the initial `initialize` handshake. */
 const INITIALIZE_TIMEOUT_MS = 30_000;
+/** Short drain window for late `session/update` chunks after a prompt RPC error. */
+const PROMPT_ERROR_DRAIN_MS = 750;
 /** ACP protocol version this client targets. */
 export const ACP_PROTOCOL_VERSION = 1;
+function stringField(obj, key) {
+    if (!obj || typeof obj !== "object")
+        return undefined;
+    const value = obj[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 /** Minimal newline-JSON-RPC framing on top of a child process's stdio. */
 class AcpConnection {
     child;
     handlers;
     logId;
+    trace;
     nextId = 1;
     pending = new Map();
     stdoutBuf = "";
     closed = false;
     closeReason = null;
-    constructor(child, handlers, logId) {
+    constructor(child, handlers, logId, trace = null) {
         this.child = child;
         this.handlers = handlers;
         this.logId = logId;
+        this.trace = trace;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.onStdout(chunk));
         child.stdout.on("end", () => this.fail(new Error("stdout closed")));
@@ -61,6 +72,7 @@ class AcpConnection {
             msg = JSON.parse(line);
         }
         catch {
+            this.trace?.write({ stream: "stdout_non_json", chunk: line });
             log.warn(`${this.logId} non-json acp line`, { line: line.slice(0, 200) });
             return;
         }
@@ -73,10 +85,25 @@ class AcpConnection {
                 return;
             this.pending.delete(msg.id);
             if (msg.error) {
+                this.trace?.write({
+                    stream: "rpc_in",
+                    direction: "in",
+                    id: msg.id,
+                    status: "error",
+                    code: typeof msg.error.code === "number" ? msg.error.code : undefined,
+                    error: msg.error.message ?? "(no message)",
+                });
                 const err = new Error(`acp error ${msg.error.code ?? "?"}: ${msg.error.message ?? "(no message)"}`);
                 pending.reject(err);
             }
             else {
+                this.trace?.write({
+                    stream: "rpc_in",
+                    direction: "in",
+                    id: msg.id,
+                    status: "response",
+                    result: msg.result ?? null,
+                });
                 pending.resolve(msg.result ?? null);
             }
             return;
@@ -84,9 +111,24 @@ class AcpConnection {
         if (typeof msg.method === "string") {
             // Server→client request (has `id`) or notification (no `id`)
             if (msg.id !== undefined) {
+                this.trace?.write({
+                    stream: "rpc_in",
+                    direction: "in",
+                    id: msg.id,
+                    method: msg.method,
+                    status: "request",
+                    params: msg.params,
+                });
                 void this.handleServerRequest(msg.id, msg.method, msg.params);
             }
             else {
+                this.trace?.write({
+                    stream: "rpc_in",
+                    direction: "in",
+                    method: msg.method,
+                    status: "notification",
+                    params: msg.params,
+                });
                 try {
                     this.handlers.onNotification(msg.method, msg.params);
                 }
@@ -114,6 +156,15 @@ class AcpConnection {
         const reply = error
             ? { jsonrpc: "2.0", id, error }
             : { jsonrpc: "2.0", id, result: result ?? null };
+        this.trace?.write({
+            stream: "rpc_out",
+            direction: "out",
+            id,
+            status: error ? "error" : "response",
+            code: error?.code,
+            error: error?.message,
+            result: error ? undefined : result ?? null,
+        });
         this.writeMessage(reply);
     }
     writeMessage(obj) {
@@ -136,10 +187,25 @@ class AcpConnection {
                 resolve: (v) => resolve(v),
                 reject,
             });
+            this.trace?.write({
+                stream: "rpc_out",
+                direction: "out",
+                id,
+                method,
+                status: "request",
+                params,
+            });
             this.writeMessage({ jsonrpc: "2.0", id, method, params });
         });
     }
     notify(method, params) {
+        this.trace?.write({
+            stream: "rpc_out",
+            direction: "out",
+            method,
+            status: "notification",
+            params,
+        });
         this.writeMessage({ jsonrpc: "2.0", method, params });
     }
     fail(err) {
@@ -205,6 +271,20 @@ export class AcpRuntimeAdapter {
             env: this.spawnEnv(opts),
             stdio: ["pipe", "pipe", "pipe"],
         });
+        const trace = createAcpTraceLogger({
+            runtime: this.id,
+            accountId: opts.accountId,
+            turnId: stringField(opts.context, "turnId"),
+            roomId: stringField(opts.context, "roomId"),
+            topicId: stringField(opts.context, "topicId") ?? null,
+            hermesProfile: opts.hermesProfile,
+            sessionId: opts.sessionId,
+        });
+        trace?.write({
+            stream: "child_start",
+            pid: child.pid,
+            params: { command: binary, args, cwd: opts.cwd },
+        });
         let killTimer = null;
         const onAbort = () => {
             if (child.killed)
@@ -235,6 +315,7 @@ export class AcpRuntimeAdapter {
         child.stderr.setEncoding("utf8");
         child.stderr.on("data", (chunk) => {
             stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CAP);
+            trace?.write({ stream: "stderr", pid: child.pid, chunk });
         });
         const state = {
             finalText: "",
@@ -289,11 +370,22 @@ export class AcpRuntimeAdapter {
                 const err = new Error(`unknown server request: ${method}`);
                 throw err;
             },
-        }, this.id);
+        }, this.id, trace);
         const childExit = new Promise((resolve) => {
-            child.on("close", (code) => resolve(code ?? 0));
+            child.on("close", (code, signal) => {
+                trace?.write({ stream: "child_exit", pid: child.pid, code, signal });
+                resolve(code ?? 0);
+            });
+            child.on("error", (err) => {
+                trace?.write({
+                    stream: "child_error",
+                    pid: child.pid,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            });
         });
         let newSessionId = opts.sessionId ?? "";
+        let promptStarted = false;
         try {
             // 1) initialize
             await this.withTimeout(conn.request("initialize", {
@@ -335,6 +427,7 @@ export class AcpRuntimeAdapter {
             }
             newSessionId = sessionId;
             // 3) session/prompt
+            promptStarted = true;
             const promptResult = (await conn.request("session/prompt", {
                 sessionId,
                 prompt: [{ type: "text", text: opts.text }],
@@ -373,6 +466,9 @@ export class AcpRuntimeAdapter {
             const tail = stderrTail.slice(-STDERR_ERROR_SNIPPET).trim();
             state.errorText =
                 state.errorText ?? (tail ? `${baseMsg}; stderr: ${tail}` : baseMsg);
+            if (promptStarted && !opts.signal.aborted) {
+                await sleepUnlessAborted(PROMPT_ERROR_DRAIN_MS, opts.signal);
+            }
             try {
                 child.stdin.end();
             }
@@ -417,3 +513,18 @@ export class AcpRuntimeAdapter {
         });
     }
 }
+function sleepUnlessAborted(ms, signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const t = setTimeout(done, ms);
+        if (typeof t.unref === "function")
+            t.unref();
+        function done() {
+            signal.removeEventListener("abort", done);
+            clearTimeout(t);
+            resolve();
+        }
+        signal.addEventListener("abort", done, { once: true });
+    });
+}

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

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { createAcpTraceLogger } from "../../acp-logs.js";
 import { readCommandVersion, resolveCommandOnPath, } from "./probe.js";
 import { consoleLogger } from "../log.js";
 const log = consoleLogger;
@@ -282,6 +283,12 @@ export class OpenclawAcpAdapter {
             }
             if (!finalText) {
                 const stopReason = pickStopReason(promptResult);
+                if (!stopReason || stopReason === "end_turn") {
+                    return {
+                        text: "",
+                        newSessionId: acpSessionId,
+                    };
+                }
                 const warningTail = handle.nonJsonStdoutTail.slice(-8).join("\n").trim();
                 const detail = warningTail ? `; stdout: ${truncateDetail(warningTail, 1000)}` : "";
                 const reason = stopReason ? `prompt stopped: ${stopReason}` : "empty assistant response";
@@ -356,10 +363,22 @@ export class OpenclawAcpAdapter {
         const args = ["acp", "--url", gateway.url];
         if (gateway.token)
             args.push("--token", gateway.token);
+        const accountId = key.split("::", 1)[0];
+        const trace = createAcpTraceLogger({
+            runtime: acpRuntimeLogName(gateway),
+            accountId,
+            gatewayName: gateway.name,
+            gatewayUrl: gateway.url,
+        });
         const child = this.spawnFn(command, args, {
             stdio: ["pipe", "pipe", "pipe"],
             env: { ...process.env },
         });
+        trace?.write({
+            stream: "child_start",
+            pid: child.pid,
+            params: { command, args, gateway: gateway.name },
+        });
         const handle = {
             child,
             pending: new Map(),
@@ -372,18 +391,26 @@ export class OpenclawAcpAdapter {
             closed: false,
             spawnedUrl: gateway.url,
             spawnedToken: gateway.token,
+            trace,
         };
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => onStdoutChunk(handle, chunk));
         child.stderr.setEncoding("utf8");
         child.stderr.on("data", (chunk) => {
+            trace?.write({ stream: "stderr", pid: child.pid, chunk });
             log.debug("openclaw-acp.stderr", { key, chunk: chunk.slice(0, 500) });
         });
         child.on("exit", (code, signal) => {
+            trace?.write({ stream: "child_exit", pid: child.pid, code, signal });
             shutdownHandle(handle, `exit code=${code ?? "null"} signal=${signal ?? "null"}`);
             ACP_POOL.delete(key);
         });
         child.on("error", (err) => {
+            trace?.write({
+                stream: "child_error",
+                pid: child.pid,
+                error: err instanceof Error ? err.message : String(err),
+            });
             log.warn("openclaw-acp.child-error", {
                 key,
                 error: err instanceof Error ? err.message : String(err),
@@ -426,6 +453,18 @@ export class OpenclawAcpAdapter {
 // ---------------------------------------------------------------------------
 // JSON-RPC stdio plumbing
 // ---------------------------------------------------------------------------
+function acpRuntimeLogName(gateway) {
+    if (gateway.name.toLowerCase().includes("qclaw"))
+        return "qclaw-acp";
+    try {
+        if (new URL(gateway.url).port === "28789")
+            return "qclaw-acp";
+    }
+    catch {
+        // Fall back to OpenClaw.
+    }
+    return "openclaw-acp";
+}
 function onStdoutChunk(handle, chunk) {
     handle.buffer += chunk;
     let idx;
@@ -447,6 +486,7 @@ function onStdoutChunk(handle, chunk) {
                 error: err instanceof Error ? err.message : String(err),
                 line: line.slice(0, 200),
             });
+            handle.trace?.write({ stream: "stdout_non_json", chunk: line });
             continue;
         }
         routeMessage(handle, msg);
@@ -461,15 +501,37 @@ function routeMessage(handle, msg) {
         handle.pending.delete(id);
         if (msg.error) {
             const message = formatRpcError(msg.error);
+            handle.trace?.write({
+                stream: "rpc_in",
+                direction: "in",
+                id,
+                status: "error",
+                code: typeof msg.error.code === "number" ? msg.error.code : undefined,
+                error: message,
+            });
             pending.reject(new Error(message));
         }
         else {
+            handle.trace?.write({
+                stream: "rpc_in",
+                direction: "in",
+                id,
+                status: "response",
+                result: msg.result ?? null,
+            });
             pending.resolve(msg.result);
         }
         return;
     }
     // Notification.
     if (msg?.method && msg?.params) {
+        handle.trace?.write({
+            stream: "rpc_in",
+            direction: "in",
+            method: msg.method,
+            status: "notification",
+            params: msg.params,
+        });
         const sid = msg.params?.sessionId;
         if (typeof sid === "string") {
             const sub = handle.subscribers.get(sid);
@@ -492,6 +554,14 @@ function sendRequest(handle, method, params) {
     return new Promise((resolve, reject) => {
         const id = handle.nextId++;
         handle.pending.set(id, { resolve, reject, method });
+        handle.trace?.write({
+            stream: "rpc_out",
+            direction: "out",
+            id,
+            method,
+            status: "request",
+            params,
+        });
         const frame = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
         try {
             handle.child.stdin.write(frame);
@@ -505,6 +575,13 @@ function sendRequest(handle, method, params) {
 function sendNotification(handle, method, params) {
     if (handle.closed)
         return;
+    handle.trace?.write({
+        stream: "rpc_out",
+        direction: "out",
+        method,
+        status: "notification",
+        params,
+    });
     const frame = JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n";
     try {
         handle.child.stdin.write(frame);

package/dist/index.js

@@ -250,6 +250,33 @@ function loadOrInitConfig(args) {
         return cfg;
     }
 }
+async function refreshDiscoveredOpenclawGateways(cfg, source) {
+    if (!openclawDiscoveryConfigEnabled(cfg))
+        return cfg;
+    try {
+        const found = await discoverLocalOpenclawGateways({
+            searchPaths: cfg.openclawDiscovery?.searchPaths,
+            defaultPorts: cfg.openclawDiscovery?.defaultPorts,
+            timeoutMs: 500,
+        });
+        const merged = mergeOpenclawGateways(cfg, found);
+        if (!merged.changed)
+            return cfg;
+        saveConfig(merged.cfg);
+        log.info("openclaw discovery: gateways merged", {
+            source,
+            added: merged.added.map((g) => ({ name: g.name, url: g.url })),
+        });
+        return merged.cfg;
+    }
+    catch (err) {
+        log.warn("openclaw discovery failed; continuing", {
+            source,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return cfg;
+    }
+}
 /**
  * Read the current user-auth record without throwing on parse / permission
  * errors — those are returned as `null` so the caller treats them like a
@@ -465,28 +492,7 @@ async function ensureUserAuthForStart(args) {
 }
 async function cmdStart(args) {
     let cfg = loadOrInitConfig(args);
-    if (openclawDiscoveryConfigEnabled(cfg)) {
-        try {
-            const found = await discoverLocalOpenclawGateways({
-                searchPaths: cfg.openclawDiscovery?.searchPaths,
-                defaultPorts: cfg.openclawDiscovery?.defaultPorts,
-                timeoutMs: 500,
-            });
-            const merged = mergeOpenclawGateways(cfg, found);
-            if (merged.changed) {
-                cfg = merged.cfg;
-                saveConfig(cfg);
-                log.info("openclaw discovery: gateways merged", {
-                    added: merged.added.map((g) => ({ name: g.name, url: g.url })),
-                });
-            }
-        }
-        catch (err) {
-            log.warn("openclaw discovery failed; continuing", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
+    cfg = await refreshDiscoveredOpenclawGateways(cfg, "start");
     // Foreground is now the default. --background (alias -d) detaches.
     // --foreground is still accepted (no-op) for backwards compatibility and
     // is also what the detached child re-execs itself with.
@@ -1241,8 +1247,8 @@ async function cmdDoctor(args) {
     let cfgForEndpoints = null;
     try {
         const cfg = loadConfig();
-        cfgForEndpoints = cfg;
-        channels = channelsFromDaemonConfig(cfg);
+        cfgForEndpoints = await refreshDiscoveredOpenclawGateways(cfg, "doctor");
+        channels = channelsFromDaemonConfig(cfgForEndpoints);
     }
     catch {
         channels = [];

package/dist/openclaw-discovery.js

@@ -304,6 +304,7 @@ export function mergeOpenclawGateways(cfg, found) {
 }
 function discoverFromConfigDir(root) {
     const dir = expandHome(root);
+    const rootIsQclaw = path.basename(dir) === ".qclaw";
     let names;
     try {
         names = readdirSync(dir);
@@ -324,8 +325,9 @@ function discoverFromConfigDir(root) {
             const parsed = name.endsWith(".json") ? parseJsonConfig(raw) : parseTomlConfig(raw);
             if (!parsed?.url)
                 continue;
+            const namePrefix = rootIsQclaw || name.toLowerCase() === "qclaw.json" ? "qclaw" : "openclaw";
             const item = {
-                name: nameFromUrl(parsed.url),
+                name: nameFromUrl(parsed.url, namePrefix),
                 url: parsed.url,
                 source: "config-file",
             };
@@ -454,24 +456,30 @@ function dedupeDiscovered(items) {
     for (const item of items) {
         const key = normalizeUrlKey(item.url);
         const prev = byUrl.get(key);
-        if (!prev || priority[item.source] > priority[prev.source] || hasMoreAuth(item, prev)) {
+        if (!prev ||
+            priority[item.source] > priority[prev.source] ||
+            hasMoreAuth(item, prev) ||
+            prefersQclawName(item, prev)) {
             byUrl.set(key, item);
         }
     }
     return [...byUrl.values()];
 }
+function prefersQclawName(a, b) {
+    return a.name.startsWith("qclaw-") && !b.name.startsWith("qclaw-");
+}
 function hasMoreAuth(a, b) {
     const score = (x) => (x.token ? 2 : x.tokenFile ? 1 : 0);
     return score(a) > score(b);
 }
-function nameFromUrl(raw) {
+function nameFromUrl(raw, prefix = "openclaw") {
     try {
         const u = new URL(raw);
         const base = `${u.hostname}-${u.port || (u.protocol === "wss:" ? "443" : "80")}`;
-        return `openclaw-${base.replace(/[^A-Za-z0-9_-]+/g, "-")}`;
+        return `${prefix}-${base.replace(/[^A-Za-z0-9_-]+/g, "-")}`;
     }
     catch {
-        return "openclaw-local";
+        return `${prefix}-local`;
     }
 }
 function uniqueName(base, existing) {

package/dist/provision.js

@@ -10,6 +10,7 @@ import path from "node:path";
 import { BotCordClient, CONTROL_FRAME_TYPES, defaultCredentialsFile, derivePublicKey, loadStoredCredentials, writeCredentialsFile, } from "@botcord/protocol-core";
 import { loadConfig, resolveConfiguredAgentIds, saveConfig, } from "./config.js";
 import { BOTCORD_CHANNEL_TYPE, buildManagedRoutes, prepareGatewayProfile, } from "./daemon-config-map.js";
+import { discoverLocalOpenclawGateways, mergeOpenclawGateways, openclawDiscoveryConfigEnabled, } from "./openclaw-discovery.js";
 import { agentHomeDir, agentStateDir, agentWorkspaceDir, applyAgentIdentity, ensureAttachedHermesProfileSkills, ensureAgentWorkspace, } from "./agent-workspace.js";
 import { detectRuntimes, getAdapterModule } from "./adapters/runtimes.js";
 import { createGatewayControl } from "./gateway-control.js";
@@ -199,6 +200,7 @@ export function createProvisioner(opts) {
                 let cfgForProbe;
                 try {
                     cfgForProbe = loadConfig();
+                    cfgForProbe = await refreshDiscoveredOpenclawGateways(cfgForProbe);
                 }
                 catch {
                     cfgForProbe = undefined;
@@ -284,6 +286,33 @@ export function createProvisioner(opts) {
         }
     };
 }
+async function refreshDiscoveredOpenclawGateways(cfg) {
+    if (!openclawDiscoveryConfigEnabled(cfg))
+        return cfg;
+    try {
+        const found = await discoverLocalOpenclawGateways({
+            searchPaths: cfg.openclawDiscovery?.searchPaths,
+            defaultPorts: cfg.openclawDiscovery?.defaultPorts,
+            timeoutMs: 500,
+        });
+        const merged = mergeOpenclawGateways(cfg, found);
+        if (!merged.changed)
+            return cfg;
+        saveConfig(merged.cfg);
+        daemonLog.info("openclaw discovery: gateways merged", {
+            source: "list_runtimes",
+            added: merged.added.map((g) => ({ name: g.name, url: g.url })),
+        });
+        return merged.cfg;
+    }
+    catch (err) {
+        daemonLog.warn("openclaw discovery failed; continuing", {
+            source: "list_runtimes",
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return cfg;
+    }
+}
 async function handleWakeAgent(gateway, raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         return {

package/package.json

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

package/src/__tests__/acp-logs.test.ts

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const originalHome = process.env.HOME;
+
+afterEach(() => {
+  if (originalHome === undefined) delete process.env.HOME;
+  else process.env.HOME = originalHome;
+  delete process.env.BOTCORD_ACP_LOGS;
+  delete process.env.BOTCORD_ACP_TRACE;
+  vi.resetModules();
+});
+
+describe("ACP trace logs", () => {
+  it("writes redacted safe-mode jsonl and lists it for diagnostics", async () => {
+    const home = mkdtempSync(path.join(tmpdir(), "botcord-acp-log-home-"));
+    process.env.HOME = home;
+    vi.resetModules();
+    const { createAcpTraceLogger, listAcpTraceLogFiles } = await import("../acp-logs.js");
+
+    const logger = createAcpTraceLogger({
+      runtime: "openclaw-acp",
+      accountId: "ag_test",
+      roomId: "rm_test",
+      gatewayName: "qclaw-127-0-0-1-28789",
+      gatewayUrl: "ws://127.0.0.1:28789",
+    });
+    expect(logger).not.toBeNull();
+    logger!.write({
+      stream: "rpc_out",
+      direction: "out",
+      id: 1,
+      method: "session/prompt",
+      status: "request",
+      params: {
+        sessionId: "sess_1",
+        token: "secret-token",
+        prompt: [{ type: "text", text: "hello from a user prompt" }],
+      },
+    });
+
+    const raw = readFileSync(logger!.path, "utf8");
+    expect(raw).toContain('"method":"session/prompt"');
+    expect(raw).toContain('"preview":"[REDACTED]"');
+    expect(raw).toContain('"textBytes"');
+    expect(raw).toContain('"textPreview"');
+    expect(raw).not.toContain("secret-token");
+    const files = listAcpTraceLogFiles();
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe(logger!.path);
+  });
+
+  it("bundles ACP and runtime logs in diagnostics", async () => {
+    const home = mkdtempSync(path.join(tmpdir(), "botcord-diag-acp-home-"));
+    process.env.HOME = home;
+    vi.resetModules();
+    const { createAcpTraceLogger } = await import("../acp-logs.js");
+    const { createDiagnosticBundle } = await import("../diagnostics.js");
+
+    const logger = createAcpTraceLogger({ runtime: "hermes-agent", accountId: "ag_hermes" });
+    logger!.write({ stream: "stderr", chunk: "hermes auth token=secret\n" });
+    const botcordDaemon = path.join(home, ".botcord", "daemon");
+    const qclawLogs = path.join(home, ".qclaw", "logs");
+    mkdirSync(botcordDaemon, { recursive: true });
+    writeFileSync(path.join(home, ".botcord", "daemon.log"), "daemon\n", { flag: "w" });
+    writeFileSync(path.join(home, ".botcord", "snapshot.json"), "{}\n", { flag: "w" });
+    writeFileSync(path.join(botcordDaemon, "config.json"), "{}\n", { flag: "w" });
+    mkdirSync(qclawLogs, { recursive: true });
+    writeFileSync(path.join(qclawLogs, "qclaw.log"), "qclaw token=secret\n");
+
+    const bundle = await createDiagnosticBundle({
+      diagnosticsDir: path.join(home, ".botcord", "diagnostics"),
+      doctor: { text: "doctor ok", json: { ok: true } },
+    });
+
+    expect(existsSync(bundle.path)).toBe(true);
+    const listing = execFileSync("unzip", ["-l", bundle.path], { encoding: "utf8" });
+    expect(listing).toContain("acp-logs/hermes-agent");
+    expect(listing).toContain("runtime-logs/qclaw/qclaw.log");
+    const acpLog = execFileSync("unzip", ["-p", bundle.path, "acp-logs/hermes-agent/ag_hermes.jsonl"], {
+      encoding: "utf8",
+    });
+    expect(acpLog).toContain("[REDACTED]");
+  });
+});