@botcord/daemon 0.2.61 → 0.2.63

package/dist/acp-logs.d.ts

@@ -0,0 +1,39 @@
+import type { LogFileEntry } from "./log.js";
+export type AcpTraceStream = "child_start" | "child_exit" | "child_error" | "stderr" | "stdout_non_json" | "rpc_in" | "rpc_out";
+export interface AcpTraceMeta {
+    runtime: string;
+    accountId?: string;
+    turnId?: string;
+    roomId?: string;
+    topicId?: string | null;
+    gatewayName?: string;
+    gatewayUrl?: string;
+    hermesProfile?: string;
+    sessionId?: string | null;
+}
+export interface AcpTraceEvent {
+    stream: AcpTraceStream;
+    direction?: "in" | "out";
+    pid?: number;
+    id?: number | string;
+    method?: string;
+    status?: "request" | "notification" | "response" | "error";
+    code?: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: string;
+    chunk?: string;
+    params?: unknown;
+    result?: unknown;
+}
+export interface AcpTraceLogger {
+    path: string;
+    verbose: boolean;
+    write(event: AcpTraceEvent): void;
+}
+interface RuntimeLogFile extends LogFileEntry {
+    bundleName: string;
+}
+export declare function createAcpTraceLogger(meta: AcpTraceMeta): AcpTraceLogger | null;
+export declare function listAcpTraceLogFiles(includeAll?: boolean): LogFileEntry[];
+export declare function listRuntimeLogFiles(includeAll?: boolean): RuntimeLogFile[];
+export {};

package/dist/acp-logs.js

@@ -0,0 +1,333 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const ACP_LOG_DIR = path.join(homedir(), ".botcord", "logs", "acp");
+const ACP_LOG_MAX_BYTES = 2 * 1024 * 1024;
+const ACP_LOG_KEEP = 20;
+const ACP_LOG_DIAGNOSTICS_DEFAULT = 10;
+const ACP_LOG_DIAGNOSTICS_ALL = 50;
+const RUNTIME_LOG_DEFAULT_PER_ROOT = 5;
+const RUNTIME_LOG_ALL_PER_ROOT = 25;
+const RUNTIME_LOG_MAX_FILE_BYTES = 2 * 1024 * 1024;
+const SECRET_KEY_RE = /token|secret|private.?key|api.?key|authorization|password/i;
+export function createAcpTraceLogger(meta) {
+    if (process.env.BOTCORD_ACP_LOGS === "0")
+        return null;
+    const runtime = safePathSegment(meta.runtime || "acp");
+    const key = safePathSegment([
+        meta.accountId,
+        meta.gatewayName,
+        meta.hermesProfile,
+        meta.roomId,
+    ].filter(Boolean).join("_") || "default");
+    const dir = path.join(ACP_LOG_DIR, runtime);
+    const file = path.join(dir, `${key}.jsonl`);
+    const verbose = process.env.BOTCORD_ACP_TRACE === "verbose";
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return {
+        path: file,
+        verbose,
+        write(event) {
+            writeAcpTrace(file, meta, event, verbose);
+        },
+    };
+}
+export function listAcpTraceLogFiles(includeAll = false) {
+    const limit = includeAll ? ACP_LOG_DIAGNOSTICS_ALL : ACP_LOG_DIAGNOSTICS_DEFAULT;
+    const out = [];
+    collectFiles(ACP_LOG_DIR, out, (name) => name.endsWith(".jsonl") || name.includes(".jsonl."));
+    return out
+        .sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name))
+        .slice(0, limit);
+}
+export function listRuntimeLogFiles(includeAll = false) {
+    const limit = includeAll ? RUNTIME_LOG_ALL_PER_ROOT : RUNTIME_LOG_DEFAULT_PER_ROOT;
+    const out = [];
+    for (const root of runtimeLogRoots()) {
+        const files = [];
+        collectFiles(root.dir, files, looksLikeLogFile, 4);
+        for (const entry of files
+            .sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name))
+            .slice(0, limit)) {
+            out.push({
+                ...entry,
+                bundleName: path.posix.join("runtime-logs", root.label, relativeBundlePath(root.dir, entry.path)),
+            });
+        }
+    }
+    return out;
+}
+function writeAcpTrace(file, meta, event, verbose) {
+    try {
+        rotateIfNeeded(file);
+        const record = {
+            ts: new Date().toISOString(),
+            runtime: meta.runtime,
+            accountId: meta.accountId,
+            turnId: meta.turnId,
+            roomId: meta.roomId,
+            topicId: meta.topicId ?? undefined,
+            gatewayName: meta.gatewayName,
+            gatewayUrl: meta.gatewayUrl,
+            hermesProfile: meta.hermesProfile,
+            sessionId: event.params && typeof event.params === "object"
+                ? pickString(event.params, "sessionId") ?? meta.sessionId ?? undefined
+                : meta.sessionId ?? undefined,
+            ...summarizeEvent(event, verbose),
+        };
+        appendFileSync(file, JSON.stringify(record) + "\n", { mode: 0o600 });
+    }
+    catch {
+        // ACP trace logging must never affect runtime execution.
+    }
+}
+function summarizeEvent(event, verbose) {
+    const out = {
+        stream: event.stream,
+    };
+    if (event.direction)
+        out.direction = event.direction;
+    if (event.pid !== undefined)
+        out.pid = event.pid;
+    if (event.id !== undefined)
+        out.id = event.id;
+    if (event.method)
+        out.method = event.method;
+    if (event.status)
+        out.status = event.status;
+    if (event.code !== undefined)
+        out.code = event.code;
+    if (event.signal !== undefined)
+        out.signal = event.signal;
+    if (event.error)
+        out.error = truncate(event.error, 1000);
+    if (event.chunk)
+        out.chunk = truncate(redactSecretString(event.chunk), 2000);
+    if (event.params !== undefined)
+        out.params = summarizePayload(event.params, verbose);
+    if (event.result !== undefined)
+        out.result = summarizePayload(event.result, verbose);
+    return out;
+}
+function summarizePayload(value, verbose) {
+    const redacted = redactSecrets(value);
+    if (verbose)
+        return capPayload(redacted);
+    if (Array.isArray(redacted))
+        return { type: "array", length: redacted.length };
+    if (!redacted || typeof redacted !== "object")
+        return redacted;
+    const obj = redacted;
+    const out = {};
+    for (const [key, v] of Object.entries(obj)) {
+        if (key === "prompt") {
+            out.prompt = summarizePrompt(v);
+        }
+        else if (key === "cwd" || key === "sessionId") {
+            out[key] = v;
+        }
+        else if (key === "_meta") {
+            out[key] = summarizePayload(v, false);
+        }
+        else if (key === "update") {
+            out.update = summarizeUpdate(v);
+        }
+        else if (key === "toolCall") {
+            out.toolCall = summarizeToolCall(v);
+        }
+        else if (typeof v === "string") {
+            out[key] = stringSummary(v);
+        }
+        else if (Array.isArray(v)) {
+            out[key] = { type: "array", length: v.length };
+        }
+        else if (v && typeof v === "object") {
+            out[key] = { type: "object", keys: Object.keys(v).slice(0, 20) };
+        }
+        else {
+            out[key] = v;
+        }
+    }
+    return out;
+}
+function summarizePrompt(value) {
+    if (!Array.isArray(value))
+        return summarizePayload(value, false);
+    return value.map((item) => {
+        if (!item || typeof item !== "object")
+            return summarizePayload(item, false);
+        const obj = item;
+        const text = typeof obj.text === "string" ? obj.text : "";
+        return {
+            type: obj.type,
+            textBytes: text ? Buffer.byteLength(text, "utf8") : undefined,
+            textPreview: text ? truncate(text.replace(/\s+/g, " "), 120) : undefined,
+        };
+    });
+}
+function summarizeUpdate(value) {
+    if (!value || typeof value !== "object")
+        return summarizePayload(value, false);
+    const obj = value;
+    const out = {};
+    if (typeof obj.sessionUpdate === "string")
+        out.sessionUpdate = obj.sessionUpdate;
+    if (typeof obj.title === "string")
+        out.title = stringSummary(obj.title);
+    if (obj.content !== undefined)
+        out.content = summarizePayload(obj.content, false);
+    return Object.keys(out).length > 0 ? out : { type: "object", keys: Object.keys(obj).slice(0, 20) };
+}
+function summarizeToolCall(value) {
+    if (!value || typeof value !== "object")
+        return summarizePayload(value, false);
+    const obj = value;
+    return {
+        name: typeof obj.name === "string" ? obj.name : undefined,
+        rawInput: obj.rawInput === undefined ? undefined : summarizePayload(obj.rawInput, false),
+    };
+}
+function redactSecrets(value) {
+    if (Array.isArray(value))
+        return value.map(redactSecrets);
+    if (!value || typeof value !== "object") {
+        return typeof value === "string" ? redactSecretString(value) : value;
+    }
+    const out = {};
+    for (const [key, v] of Object.entries(value)) {
+        out[key] = SECRET_KEY_RE.test(key) ? "[REDACTED]" : redactSecrets(v);
+    }
+    return out;
+}
+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]");
+}
+function capPayload(value) {
+    if (typeof value === "string")
+        return truncate(value, 2000);
+    if (Array.isArray(value))
+        return value.slice(0, 50).map(capPayload);
+    if (!value || typeof value !== "object")
+        return value;
+    const out = {};
+    for (const [key, v] of Object.entries(value).slice(0, 50)) {
+        out[key] = capPayload(v);
+    }
+    return out;
+}
+function stringSummary(value) {
+    return {
+        bytes: Buffer.byteLength(value, "utf8"),
+        preview: truncate(value.replace(/\s+/g, " "), 160),
+    };
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+function pickString(obj, key) {
+    const value = obj[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function rotateIfNeeded(file) {
+    try {
+        const st = statSync(file);
+        if (!st.isFile() || st.size <= ACP_LOG_MAX_BYTES)
+            return;
+        renameSync(file, `${file}.${new Date().toISOString().replace(/[:.]/g, "-")}.${process.pid}`);
+        const dir = path.dirname(file);
+        const base = path.basename(file);
+        const rotated = readdirSync(dir)
+            .filter((name) => name.startsWith(`${base}.`))
+            .map((name) => {
+            const p = path.join(dir, name);
+            const st = statSync(p);
+            return { p, mtimeMs: st.mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const entry of rotated.slice(ACP_LOG_KEEP))
+            unlinkSync(entry.p);
+    }
+    catch {
+        // best-effort
+    }
+}
+function collectFiles(dir, out, accept, maxDepth = 3) {
+    if (maxDepth < 0)
+        return;
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const file = path.join(dir, name);
+        try {
+            const st = statSync(file);
+            if (st.isDirectory()) {
+                collectFiles(file, out, accept, maxDepth - 1);
+            }
+            else if (st.isFile() && st.size <= RUNTIME_LOG_MAX_FILE_BYTES && accept(name, file)) {
+                out.push({
+                    path: file,
+                    name: path.relative(ACP_LOG_DIR, file) || name,
+                    sizeBytes: st.size,
+                    mtimeMs: st.mtimeMs,
+                    active: true,
+                });
+            }
+        }
+        catch {
+            // ignore disappearing files
+        }
+    }
+}
+function runtimeLogRoots() {
+    const roots = [
+        { label: "openclaw", dir: path.join(homedir(), ".openclaw", "logs") },
+        { label: "qclaw", dir: path.join(homedir(), ".qclaw", "logs") },
+        { label: "hermes", dir: path.join(homedir(), ".hermes", "logs") },
+    ];
+    const hermesProfiles = path.join(homedir(), ".hermes", "profiles");
+    try {
+        for (const name of readdirSync(hermesProfiles)) {
+            roots.push({
+                label: path.posix.join("hermes-profiles", safePathSegment(name)),
+                dir: path.join(hermesProfiles, name, "logs"),
+            });
+        }
+    }
+    catch {
+        // no profiles
+    }
+    const botcordAgents = path.join(homedir(), ".botcord", "agents");
+    try {
+        for (const agent of readdirSync(botcordAgents)) {
+            roots.push({
+                label: path.posix.join("botcord-hermes", safePathSegment(agent)),
+                dir: path.join(botcordAgents, agent, "hermes-home", "logs"),
+            });
+        }
+    }
+    catch {
+        // no botcord agent homes
+    }
+    return roots.filter((root) => existsSync(root.dir));
+}
+function looksLikeLogFile(name) {
+    const lower = name.toLowerCase();
+    return (lower.endsWith(".log") ||
+        lower.endsWith(".jsonl") ||
+        lower.endsWith(".txt") ||
+        lower.includes("log"));
+}
+function relativeBundlePath(root, file) {
+    return path.relative(root, file).split(path.sep).map(safePathSegment).join("/");
+}
+function safePathSegment(raw) {
+    return raw.replace(/[^A-Za-z0-9._-]+/g, "_").slice(0, 120) || "unknown";
+}

package/dist/diagnostics.d.ts

@@ -5,6 +5,7 @@ export interface CreateDiagnosticBundleOptions {
     logFile?: string;
     configFile?: string;
     snapshotFile?: string;
+    sessionsFile?: string;
     doctor?: {
         text: string;
         json: unknown;

package/dist/diagnostics.js

@@ -2,15 +2,38 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname, platform, release, arch } from "node:os";
 import path from "node:path";
 import { Buffer } from "node:buffer";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 import { deflateRawSync } from "node:zlib";
 import { AUTH_EXPIRED_FLAG_PATH, USER_AUTH_PATH, } from "./user-auth.js";
-import { CONFIG_FILE_PATH, PID_PATH, SNAPSHOT_PATH, loadConfig, } from "./config.js";
+import { CONFIG_FILE_PATH, PID_PATH, SESSIONS_PATH, SNAPSHOT_PATH, loadConfig, saveConfig, } from "./config.js";
 import { listDaemonLogFiles, LOG_FILE_PATH } from "./log.js";
+import { listAcpTraceLogFiles, listRuntimeLogFiles } from "./acp-logs.js";
 import { channelsFromDaemonConfig, defaultHttpFetcher, renderDoctor, runDoctor, } from "./doctor.js";
 import { detectRuntimes } from "./adapters/runtimes.js";
+import { log as daemonLog } from "./log.js";
+import { discoverLocalOpenclawGateways, mergeOpenclawGateways, openclawDiscoveryConfigEnabled, } from "./openclaw-discovery.js";
 const DIAGNOSTICS_DIR = path.join(homedir(), ".botcord", "diagnostics");
 const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
 const DEFAULT_ROTATED_LOGS_IN_BUNDLE = 5;
+const require = createRequire(import.meta.url);
+const MODULE_PATH = fileURLToPath(import.meta.url);
+const ENV_ALLOWLIST = new Set([
+    "NODE_ENV",
+    "PATH",
+    "BOTCORD_HUB",
+    "BOTCORD_DAEMON_HOME",
+    "BOTCORD_DAEMON_CONFIG",
+    "BOTCORD_DAEMON_LOG",
+    "BOTCORD_DAEMON_SNAPSHOT_INTERVAL_MS",
+    "BOTCORD_HERMES_AGENT_BIN",
+    "BOTCORD_CLAUDE_CODE_BIN",
+    "BOTCORD_CODEX_BIN",
+    "BOTCORD_GEMINI_BIN",
+    "BOTCORD_DEEPSEEK_TUI_BIN",
+    "BOTCORD_KIMI_CLI_BIN",
+    "OPENCLAW_ACP_URL",
+]);
 const SECRET_PATTERNS = [
     [/(Authorization:\s*Bearer\s+)[^\s"']+/gi, "$1[REDACTED]"],
     [/("?(?:accessToken|access_token|refreshToken|refresh_token|token|privateKey|private_key|secret)"?\s*:\s*")[^"]+(")/gi, "$1[REDACTED]$2"],
@@ -35,6 +58,82 @@ function safeReadText(file) {
         return `read failed: ${err instanceof Error ? err.message : String(err)}\n`;
     }
 }
+function readJsonFile(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findDaemonPackageJson(startFile) {
+    let dir = path.dirname(startFile);
+    for (let i = 0; i < 6; i += 1) {
+        const candidate = path.join(dir, "package.json");
+        const parsed = readJsonFile(candidate);
+        if (parsed?.name === "@botcord/daemon")
+            return parsed;
+        const next = path.dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    return null;
+}
+function readInstalledPackageVersion(packageJsonSpecifier) {
+    try {
+        const pkgPath = require.resolve(packageJsonSpecifier);
+        const parsed = readJsonFile(pkgPath);
+        return typeof parsed?.version === "string" ? parsed.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+function daemonRuntimeSummary() {
+    const pkg = findDaemonPackageJson(MODULE_PATH);
+    const version = typeof pkg?.version === "string" ? pkg.version : null;
+    const startedAtMs = Date.now() - Math.round(process.uptime() * 1000);
+    return {
+        packageName: typeof pkg?.name === "string" ? pkg.name : "@botcord/daemon",
+        version,
+        modulePath: MODULE_PATH,
+        entrypoint: process.argv[1] ?? null,
+        execPath: process.execPath,
+        argv: process.argv.map((arg) => redact(arg)),
+        execArgv: process.execArgv.map((arg) => redact(arg)),
+        cwd: process.cwd(),
+        pid: process.pid,
+        ppid: process.ppid,
+        uptimeSec: Math.round(process.uptime()),
+        startedAt: new Date(startedAtMs).toISOString(),
+        versions: {
+            node: process.version,
+            v8: process.versions.v8,
+            uv: process.versions.uv,
+            openssl: process.versions.openssl,
+        },
+        packages: {
+            "@botcord/daemon": version,
+            "@botcord/cli": readInstalledPackageVersion("@botcord/cli/package.json"),
+            "@botcord/protocol-core": readInstalledPackageVersion("@botcord/protocol-core/package.json"),
+        },
+    };
+}
+function safeEnvironmentSummary() {
+    const out = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (!value)
+            continue;
+        if (!ENV_ALLOWLIST.has(key) && !key.startsWith("BOTCORD_DAEMON_"))
+            continue;
+        out[key] = redact(value);
+    }
+    return out;
+}
 function readUserAuthSummary() {
     const raw = safeReadText(USER_AUTH_PATH);
     if (!raw)
@@ -76,6 +175,7 @@ async function buildDoctorEntries() {
     let cfgForEndpoints = null;
     try {
         cfgForEndpoints = loadConfig();
+        cfgForEndpoints = await refreshDiscoveredOpenclawGateways(cfgForEndpoints);
         channels = channelsFromDaemonConfig(cfgForEndpoints);
     }
     catch {
@@ -99,6 +199,33 @@ async function buildDoctorEntries() {
     });
     return { text: renderDoctor(input), json: input };
 }
+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: "diagnostics",
+            added: merged.added.map((g) => ({ name: g.name, url: g.url })),
+        });
+        return merged.cfg;
+    }
+    catch (err) {
+        daemonLog.warn("openclaw discovery failed; continuing", {
+            source: "diagnostics",
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return cfg;
+    }
+}
 function crc32(buf) {
     let crc = 0xffffffff;
     for (const b of buf) {
@@ -229,8 +356,11 @@ export async function createDiagnosticBundle(opts = {}) {
     const logFile = opts.logFile ?? LOG_FILE_PATH;
     const configFile = opts.configFile ?? CONFIG_FILE_PATH;
     const snapshotFile = opts.snapshotFile ?? SNAPSHOT_PATH;
+    const sessionsFile = opts.sessionsFile ?? SESSIONS_PATH;
     const includeAllLogs = opts.includeAllLogs === true;
     const logs = bundledLogs(logFile, includeAllLogs);
+    const acpLogs = listAcpTraceLogFiles(includeAllLogs);
+    const runtimeLogs = listRuntimeLogFiles(includeAllLogs);
     mkdirSync(diagnosticsDir, { recursive: true, mode: 0o700 });
     const doctor = opts.doctor ?? await buildDoctorEntries();
     const status = {
@@ -240,9 +370,12 @@ export async function createDiagnosticBundle(opts = {}) {
         release: release(),
         arch: arch(),
         node: process.version,
+        daemon: daemonRuntimeSummary(),
+        environment: safeEnvironmentSummary(),
         pidPath: PID_PATH,
         pid: process.pid,
         configPath: configFile,
+        sessionsPath: sessionsFile,
         snapshotPath: snapshotFile,
         logPath: logFile,
         logsBundled: logs.map((entry) => ({
@@ -251,6 +384,16 @@ export async function createDiagnosticBundle(opts = {}) {
             sizeBytes: entry.sizeBytes,
             active: entry.active,
         })),
+        acpLogsBundled: acpLogs.map((entry) => ({
+            name: entry.name,
+            path: entry.path,
+            sizeBytes: entry.sizeBytes,
+        })),
+        runtimeLogsBundled: runtimeLogs.map((entry) => ({
+            name: entry.bundleName,
+            path: entry.path,
+            sizeBytes: entry.sizeBytes,
+        })),
         logsBundleMode: includeAllLogs ? "all" : `active_plus_${DEFAULT_ROTATED_LOGS_IN_BUNDLE}_rotated`,
         diagnosticsDir,
         userAuth: readUserAuthSummary(),
@@ -276,6 +419,20 @@ export async function createDiagnosticBundle(opts = {}) {
             });
         }
     }
+    for (const entry of acpLogs) {
+        const log = safeReadText(entry.path);
+        entries.push({
+            name: `acp-logs/${entry.name.split(path.sep).join("/")}`,
+            data: log ?? `no ACP log file at ${entry.path}\n`,
+        });
+    }
+    for (const entry of runtimeLogs) {
+        const log = safeReadText(entry.path);
+        entries.push({
+            name: entry.bundleName,
+            data: log ?? `no runtime log file at ${entry.path}\n`,
+        });
+    }
     const config = safeReadText(configFile);
     entries.push({
         name: "config.json.redacted",
@@ -286,6 +443,11 @@ export async function createDiagnosticBundle(opts = {}) {
         name: "snapshot.json",
         data: snapshot ?? `no snapshot file at ${snapshotFile}\n`,
     });
+    const sessions = safeReadText(sessionsFile);
+    entries.push({
+        name: "sessions.json.redacted",
+        data: sessions ?? `no sessions file at ${sessionsFile}\n`,
+    });
     const zip = createZip(entries);
     const out = path.join(diagnosticsDir, filename);
     writeFileSync(out, zip, { mode: 0o600 });

package/dist/gateway/dispatcher.js

@@ -959,6 +959,14 @@ export class Dispatcher {
                     systemContext,
                     onBlock,
                     onStatus,
+                    context: {
+                        turnId,
+                        messageId: msg.id,
+                        roomId: msg.conversation.id,
+                        topicId: msg.conversation.threadId ?? null,
+                        channel: msg.channel,
+                        conversationKind: msg.conversation.kind,
+                    },
                     gateway: route.gateway,
                     ...(route.hermesProfile ? { hermesProfile: route.hermesProfile } : {}),
                 });
@@ -1087,16 +1095,35 @@ export class Dispatcher {
             }
             if (!result)
                 return;
+            const replyText = (result.text || "").trim();
+            const finalTextField = truncateTextField(result.text || "");
             // Persist session before reply so next turn sees the new id even if send fails.
             //
             // Adapter contract:
-            //   result.newSessionId truthy  → upsert the entry
-            //   result.newSessionId empty + had-inbound-sessionId + result.error
-            //                               → the prior session is dead (e.g. Claude Code
-            //                                 "--resume <missing-uuid>"); delete the entry so
+            //   had-inbound-sessionId + result.error + no reply text
+            //                               → the prior session is suspect/dead; delete it so
             //                                 we don't keep resuming a stale id every turn
+            //                                 even when the adapter echoes that id back
+            //   result.newSessionId truthy  → upsert the entry
             //   otherwise                   → no-op (e.g. codex intentionally never persists)
-            if (result.newSessionId) {
+            if (sessionId && result.error && !replyText) {
+                try {
+                    await this.sessionStore.delete(key);
+                    this.log.info("dispatcher: dropped stale runtime session", {
+                        key,
+                        prevRuntimeSessionId: sessionId,
+                        nextRuntimeSessionId: result.newSessionId || null,
+                        error: result.error,
+                    });
+                }
+                catch (err) {
+                    this.log.warn("dispatcher: session-store.delete failed", {
+                        key,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            else if (result.newSessionId) {
                 const session = {
                     key,
                     runtime: route.runtime,
@@ -1141,8 +1168,6 @@ export class Dispatcher {
                     });
                 }
             }
-            const replyText = (result.text || "").trim();
-            const finalTextField = truncateTextField(result.text || "");
             if (!replyText) {
                 if (result.error) {
                     this.log.warn("dispatcher: runtime returned error without reply text", {