@botcord/daemon 0.2.85 → 0.2.87

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BotLearn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cloud-daemon.js

@@ -17,7 +17,7 @@ import { ControlChannel } from "./control-channel.js";
 import { toGatewayConfig } from "./daemon-config-map.js";
 import { log as daemonLog } from "./log.js";
 import { createProvisioner } from "./provision.js";
-import { createDaemonChannel, pushRuntimeSnapshot } from "./daemon.js";
+import { createDaemonChannel, pushAgentSkillSnapshot, pushRuntimeSnapshot } from "./daemon.js";
 import { SnapshotWriter } from "./snapshot-writer.js";
 import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
@@ -157,7 +157,25 @@ export async function startCloudDaemon(opts) {
             text: msg.text,
         });
     };
+    const installedAgentIds = new Set();
+    const runtimeByAgentId = new Map();
+    let controlChannel = null;
+    const pushInstalledAgentSkillSnapshot = (agentId, reason) => {
+        if (!controlChannel)
+            return;
+        const runtime = runtimeByAgentId.get(agentId) ?? opts.config.defaultRoute.adapter;
+        const pushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+        logger.info("cloud control-channel: agent_skill_snapshot pushed", {
+            agentId,
+            runtime,
+            reason,
+            ok: pushed,
+        });
+    };
     const onAgentInstalled = (info) => {
+        installedAgentIds.add(info.agentId);
+        if (info.runtime)
+            runtimeByAgentId.set(info.agentId, info.runtime);
         credentialPathByAgentId.set(info.agentId, info.credentialsFile);
         if (info.hubUrl)
             hubUrlByAgentId.set(info.agentId, info.hubUrl);
@@ -173,6 +191,7 @@ export async function startCloudDaemon(opts) {
                 loopRiskBuilder: () => null,
             }));
         }
+        pushInstalledAgentSkillSnapshot(info.agentId, "agent_installed");
     };
     const gateway = new Gateway({
         config: gwConfig,
@@ -197,7 +216,6 @@ export async function startCloudDaemon(opts) {
     });
     await gateway.start();
     logger.info("cloud daemon gateway started (zero agents at boot)");
-    let controlChannel = null;
     if (!opts.disableControlChannel) {
         const auth = asUserAuthManager(new CloudAuthManager(cloudCfg));
         const provisionerFactory = opts.provisionerFactory ?? createProvisioner;
@@ -247,6 +265,9 @@ export async function startCloudDaemon(opts) {
             logger.info("cloud control-channel started; runtime_snapshot pushed", {
                 ok: pushed,
             });
+            for (const agentId of installedAgentIds) {
+                pushInstalledAgentSkillSnapshot(agentId, "control_channel_started");
+            }
         }
         catch (err) {
             logger.warn("cloud control-channel start failed; daemon will retry", {

package/dist/daemon-singleton.d.ts

@@ -2,6 +2,11 @@ export interface SingletonLogger {
     info(message: string, meta?: Record<string, unknown>): void;
     warn(message: string, meta?: Record<string, unknown>): void;
 }
+export interface DaemonSingletonLock {
+    lockPath: string;
+    release(): void;
+}
+export declare function defaultLockPath(pidPath?: string): string;
 export declare function readPid(pidPath?: string): number | null;
 export declare function pidAlive(pid: number): boolean;
 export interface DaemonProcessInfo {
@@ -23,6 +28,13 @@ export declare function stopDaemonFromPidFileForRestart(opts?: {
     currentPid?: number;
     logger?: SingletonLogger;
 }): Promise<void>;
+export declare function acquireDaemonSingletonLock(opts?: {
+    lockPath?: string;
+    pidPath?: string;
+    currentPid?: number;
+    logger?: SingletonLogger;
+    timeoutMs?: number;
+}): Promise<DaemonSingletonLock>;
 export declare function stopOtherDaemonProcessesForRestart(opts?: {
     currentPid?: number;
     logger?: SingletonLogger;

package/dist/daemon-singleton.js

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { PID_PATH } from "./config.js";
 const noopLogger = {
@@ -10,6 +10,11 @@ const noopLogger = {
         // noop
     },
 };
+const DEFAULT_LOCK_WAIT_MS = 15_000;
+const DEFAULT_LOCK_RETRY_MS = 50;
+export function defaultLockPath(pidPath = PID_PATH) {
+    return `${pidPath}.lock`;
+}
 export function readPid(pidPath = PID_PATH) {
     if (!existsSync(pidPath))
         return null;
@@ -17,6 +22,9 @@ export function readPid(pidPath = PID_PATH) {
     const pid = Number(raw);
     return Number.isFinite(pid) && pid > 0 ? pid : null;
 }
+function readLockOwner(lockPath) {
+    return readPid(path.join(lockPath, "owner.pid"));
+}
 export function pidAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -98,6 +106,71 @@ export async function stopDaemonFromPidFileForRestart(opts = {}) {
         await stopExistingDaemonForRestart(existing, opts);
     }
 }
+export async function acquireDaemonSingletonLock(opts = {}) {
+    const pidPath = opts.pidPath ?? PID_PATH;
+    const lockPath = opts.lockPath ?? defaultLockPath(pidPath);
+    const currentPid = opts.currentPid ?? process.pid;
+    const logger = opts.logger ?? noopLogger;
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_LOCK_WAIT_MS;
+    const deadline = Date.now() + timeoutMs;
+    ensureParentDir(lockPath);
+    while (true) {
+        try {
+            mkdirSync(lockPath, { mode: 0o700 });
+            writeFileSync(path.join(lockPath, "owner.pid"), String(currentPid), { mode: 0o600 });
+            return {
+                lockPath,
+                release() {
+                    const owner = readLockOwner(lockPath);
+                    if (owner !== null && owner !== currentPid)
+                        return;
+                    try {
+                        rmSync(lockPath, { recursive: true, force: true });
+                    }
+                    catch {
+                        // ignore
+                    }
+                },
+            };
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST")
+                throw err;
+        }
+        const owner = readLockOwner(lockPath);
+        if (owner === currentPid) {
+            return {
+                lockPath,
+                release() {
+                    try {
+                        rmSync(lockPath, { recursive: true, force: true });
+                    }
+                    catch {
+                        // ignore
+                    }
+                },
+            };
+        }
+        if (owner !== null && pidAlive(owner)) {
+            logger.info("daemon singleton lock owner found; restarting", { pid: owner });
+            await stopExistingDaemonForRestart(owner, { pidPath, currentPid, logger });
+        }
+        const refreshedOwner = readLockOwner(lockPath);
+        if (refreshedOwner === null || !pidAlive(refreshedOwner)) {
+            try {
+                rmSync(lockPath, { recursive: true, force: true });
+            }
+            catch {
+                // another starter may have removed/recreated it
+            }
+        }
+        if (Date.now() >= deadline) {
+            throw new Error(`timed out acquiring daemon singleton lock at ${lockPath}`);
+        }
+        await delay(DEFAULT_LOCK_RETRY_MS);
+    }
+}
 export async function stopOtherDaemonProcessesForRestart(opts = {}) {
     const currentPid = opts.currentPid ?? process.pid;
     const logger = opts.logger ?? noopLogger;
@@ -142,12 +215,7 @@ export function writeCurrentPid(opts = {}) {
     // Cloud-mode startup writes the PID file before `saveConfig` runs, so
     // the daemon dir may not exist yet. mkdir its parent (0700) so the
     // first write doesn't crash with ENOENT.
-    try {
-        mkdirSync(path.dirname(pidPath), { recursive: true, mode: 0o700 });
-    }
-    catch {
-        // best-effort — writeFileSync below will surface the real error
-    }
+    ensureParentDir(pidPath);
     writeFileSync(pidPath, String(opts.currentPid ?? process.pid), { mode: 0o600 });
 }
 export function removePidFile(pidPath = PID_PATH) {
@@ -186,3 +254,11 @@ export function isBotCordDaemonStartCommand(command) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function ensureParentDir(filePath) {
+    try {
+        mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    }
+    catch {
+        // best-effort — the next filesystem operation will surface real errors
+    }
+}

package/dist/daemon.d.ts

@@ -65,6 +65,9 @@ export interface RuntimeSnapshotSink {
  * or wait for the next daemon restart). Exported for unit tests.
  */
 export declare function pushRuntimeSnapshot(sink: RuntimeSnapshotSink, liveSnapshot?: GatewayRuntimeSnapshot): boolean;
+export declare function pushAgentSkillSnapshot(sink: RuntimeSnapshotSink, agentId: string, opts?: {
+    runtime?: string;
+}): boolean;
 /** Options accepted by {@link startDaemon} — the P0.5 compatibility shim. */
 export interface DaemonRuntimeOptions {
     config: DaemonConfig;

package/dist/daemon.js

@@ -22,6 +22,7 @@ import { PolicyResolver } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
 import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
+import { collectAgentSkillSnapshot } from "./skill-index.js";
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
  * tasks routinely exceed 10 minutes, so daemon-hosted agents get a larger
@@ -164,6 +165,22 @@ export function pushRuntimeSnapshot(sink, liveSnapshot) {
     }
     return ok;
 }
+export function pushAgentSkillSnapshot(sink, agentId, opts = {}) {
+    const snap = collectAgentSkillSnapshot(agentId, opts);
+    const ok = sink.send({
+        id: `skill_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        type: "agent_skill_snapshot",
+        params: snap,
+        ts: Date.now(),
+    });
+    if (!ok) {
+        daemonLog.warn("agent-skill-snapshot: control-channel send returned false", {
+            agentId,
+            skills: snap.skills.length,
+        });
+    }
+    return ok;
+}
 /**
  * Adapt daemon's file-based `log` module into the gateway logger contract.
  * Writes go to `~/.botcord/logs/daemon.log` + stderr, preserving the format
@@ -355,6 +372,12 @@ export async function startDaemon(opts) {
         // next room-context fetch re-loads the BotCordClient against the new
         // credential file.
         credentialPathByAgentId.set(info.agentId, info.credentialsFile);
+        if (info.runtime) {
+            agentRuntimes[info.agentId] = {
+                ...(agentRuntimes[info.agentId] ?? {}),
+                runtime: info.runtime,
+            };
+        }
         if (info.hubUrl)
             hubUrlByAgentId.set(info.agentId, info.hubUrl);
         if (info.displayName)
@@ -483,6 +506,15 @@ export async function startDaemon(opts) {
             logger.info("control-channel: initial runtime_snapshot push", {
                 ok: pushed,
             });
+            for (const agentId of agentIds) {
+                const runtime = agentRuntimes[agentId]?.runtime ?? opts.config.defaultRoute.adapter;
+                const skillsPushed = pushAgentSkillSnapshot(controlChannel, agentId, { runtime });
+                logger.info("control-channel: initial agent_skill_snapshot push", {
+                    agentId,
+                    runtime,
+                    ok: skillsPushed,
+                });
+            }
         }
         catch (err) {
             logger.warn("control-channel failed to start; continuing without it", {

package/dist/gateway/channels/botcord.js

@@ -1044,24 +1044,39 @@ function extractDeepseekToolCall(raw) {
     const payload = raw?.payload;
     if (!payload || typeof payload !== "object")
         return null;
-    if (raw?.event === "tool.started") {
-        const tool = payload.tool && typeof payload.tool === "object" ? payload.tool : undefined;
+    const innerPayload = unwrapDeepseekPayload(raw);
+    const event = stringField(raw, "event") ?? stringField(payload, "event");
+    if (event === "tool.started") {
+        const tool = innerPayload?.tool && typeof innerPayload.tool === "object" ? innerPayload.tool : undefined;
         return {
-            name: stringField(payload, "name") ?? stringField(tool, "name") ?? "tool",
-            params: parseMaybeJson(payload.input ?? payload.arguments ?? payload.params ?? tool?.input ?? tool?.rawInput),
-            id: stringField(payload, "id") ?? stringField(tool, "id"),
-            status: stringField(payload, "status") ?? stringField(tool, "status"),
+            name: stringField(innerPayload, "name") ?? stringField(tool, "name") ?? "tool",
+            params: parseMaybeJson(innerPayload?.input ??
+                innerPayload?.arguments ??
+                innerPayload?.params ??
+                tool?.input ??
+                tool?.rawInput ??
+                tool?.arguments ??
+                tool?.params),
+            id: stringField(innerPayload, "id") ?? stringField(tool, "id"),
+            status: stringField(innerPayload, "status") ?? stringField(tool, "status"),
         };
     }
-    if (raw?.event === "item.started" || payload.event === "item.started") {
-        const inner = raw?.event === "item.started"
-            ? payload
-            : payload.payload && typeof payload.payload === "object"
-                ? payload.payload
-                : {};
+    if (event === "item.started") {
+        const inner = innerPayload ?? {};
         const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
         const tool = inner.tool && typeof inner.tool === "object" ? inner.tool : item?.tool;
-        const itemParams = parseMaybeJson(item?.input ?? item?.arguments ?? item?.detail);
+        const metadata = item?.metadata && typeof item.metadata === "object" ? item.metadata : undefined;
+        const metadataCommand = metadata && (metadata.command ?? metadata.cmd)
+            ? { [metadata.command ? "command" : "cmd"]: metadata.command ?? metadata.cmd }
+            : undefined;
+        const itemParams = parseMaybeJson(item?.input ??
+            item?.arguments ??
+            item?.params ??
+            metadata?.input ??
+            metadata?.arguments ??
+            metadata?.params ??
+            metadataCommand ??
+            item?.detail);
         const detailParams = itemParams !== undefined
             ? itemParams
             : typeof item?.detail === "string" && item.detail.trim()
@@ -1082,8 +1097,16 @@ function extractDeepseekToolCall(raw) {
                 inner.arguments ??
                 inner.params ??
                 item?.input ??
-                item?.arguments) ?? detailParams ?? tool ?? item,
-            id: stringField(tool, "id") ?? stringField(inner, "id") ?? stringField(item, "id"),
+                item?.arguments ??
+                item?.params ??
+                metadata?.input ??
+                metadata?.arguments ??
+                metadata?.params ??
+                metadataCommand) ?? detailParams ?? tool ?? item,
+            id: stringField(tool, "id") ??
+                stringField(inner, "id") ??
+                stringField(item, "id") ??
+                stringField(payload, "item_id"),
             status: stringField(tool, "status") ?? stringField(inner, "status") ?? stringField(item, "status"),
         };
     }
@@ -1093,23 +1116,23 @@ function extractDeepseekToolResult(raw) {
     const payload = raw?.payload;
     if (!payload || typeof payload !== "object")
         return null;
-    if (raw?.event === "tool.completed") {
-        const result = payload.output ?? payload.result ?? payload.content ?? payload.error ?? payload;
+    const innerPayload = unwrapDeepseekPayload(raw);
+    const event = stringField(raw, "event") ?? stringField(payload, "event");
+    if (event === "tool.completed") {
+        const result = innerPayload?.output ??
+            innerPayload?.result ??
+            innerPayload?.content ??
+            innerPayload?.error ??
+            innerPayload ??
+            payload;
         return {
-            name: stringField(payload, "name"),
+            name: stringField(innerPayload, "name"),
             result: stringifyToolResult(result),
-            id: stringField(payload, "id"),
+            id: stringField(innerPayload, "id"),
         };
     }
-    if (raw?.event === "item.completed" ||
-        raw?.event === "item.failed" ||
-        payload.event === "item.completed" ||
-        payload.event === "item.failed") {
-        const inner = raw?.event === "item.completed" || raw?.event === "item.failed"
-            ? payload
-            : payload.payload && typeof payload.payload === "object"
-                ? payload.payload
-                : {};
+    if (event === "item.completed" || event === "item.failed") {
+        const inner = innerPayload ?? {};
         const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
         const result = item?.output ??
             item?.result ??
@@ -1128,11 +1151,31 @@ function extractDeepseekToolResult(raw) {
                 stringField(inner, "name") ??
                 stringField(item, "type"),
             result: stringifyToolResult(result),
-            id: stringField(item, "id") ?? stringField(inner, "id"),
+            id: stringField(item, "id") ?? stringField(inner, "id") ?? stringField(payload, "item_id"),
         };
     }
     return null;
 }
+function unwrapDeepseekPayload(raw) {
+    const payload = raw?.payload;
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const nested = payload.payload;
+    if (nested && typeof nested === "object") {
+        const outerEvent = stringField(payload, "event");
+        if (outerEvent ||
+            nested.item ||
+            nested.tool ||
+            nested.turn ||
+            nested.kind ||
+            nested.output ||
+            nested.result ||
+            nested.error) {
+            return nested;
+        }
+    }
+    return payload;
+}
 function formatBlockDetails(raw) {
     if (!raw || typeof raw !== "object")
         return "";

package/dist/gateway/dispatcher.d.ts

@@ -2,6 +2,22 @@ import type { GatewayLogger } from "./log.js";
 import { type SessionStore } from "./session-store.js";
 import { type TranscriptWriter } from "./transcript.js";
 import type { ChannelAdapter, GatewayConfig, GatewayInboundEnvelope, GatewayInboundMessage, GatewayRoute, InboundObserver, MemoryContextBuilder, OutboundObserver, RuntimeAdapter, RuntimeRecoveryContextBuilder, RuntimeRunResult, RuntimeCircuitBreakerSnapshot, SystemContextBuilder, TurnStatusSnapshot, UserTurnBuilder } from "./types.js";
+/**
+ * Pick the canonical reply_to value to attach to outbound replies for a given
+ * inbound `GatewayInboundMessage`. Priority:
+ *
+ *   1. `msg.replyTo` — the inbound was itself a reply; preserve the chain so
+ *      receipts and threaded replies point at the original target.
+ *   2. `raw.envelope.msg_id` — the wire-protocol identifier (UUID per a2a/0.1).
+ *      This is the canonical form the hub stores in `reply_to_msg_id`.
+ *   3. `msg.id` — fallback to the hub_msg_id (`h_*`) the BotCord channel
+ *      stamps on every inbound. The hub accepts this form via
+ *      `_load_reply_target`'s prefix-based discriminator, but emitting it is
+ *      lossy because the hub then has to resolve it back to msg_id.
+ *
+ * Exported for unit testing; production code paths use Dispatcher.providerReplyTo.
+ */
+export declare function pickReplyToTarget(msg: GatewayInboundMessage): string;
 /** Factory signature for building a runtime adapter at turn dispatch time. */
 export type RuntimeFactory = (runtimeId: string, extraArgs?: string[]) => RuntimeAdapter;
 /** Constructor options for `Dispatcher`. */

package/dist/gateway/dispatcher.js

@@ -143,6 +143,30 @@ function buildRuntimeRecoveryPrompt(args) {
         args.userTurn,
     ].join("\n");
 }
+/**
+ * Pick the canonical reply_to value to attach to outbound replies for a given
+ * inbound `GatewayInboundMessage`. Priority:
+ *
+ *   1. `msg.replyTo` — the inbound was itself a reply; preserve the chain so
+ *      receipts and threaded replies point at the original target.
+ *   2. `raw.envelope.msg_id` — the wire-protocol identifier (UUID per a2a/0.1).
+ *      This is the canonical form the hub stores in `reply_to_msg_id`.
+ *   3. `msg.id` — fallback to the hub_msg_id (`h_*`) the BotCord channel
+ *      stamps on every inbound. The hub accepts this form via
+ *      `_load_reply_target`'s prefix-based discriminator, but emitting it is
+ *      lossy because the hub then has to resolve it back to msg_id.
+ *
+ * Exported for unit testing; production code paths use Dispatcher.providerReplyTo.
+ */
+export function pickReplyToTarget(msg) {
+    if (msg.replyTo)
+        return msg.replyTo;
+    const raw = msg.raw;
+    const envMsgId = raw && typeof raw.envelope?.msg_id === "string" && raw.envelope.msg_id
+        ? raw.envelope.msg_id
+        : null;
+    return envMsgId ?? msg.id;
+}
 /**
  * Reason carried on `AbortController.abort()` when a cancel-previous wave
  * is taking over the slot. Distinguishing this from a timeout abort lets
@@ -1775,7 +1799,7 @@ export class Dispatcher {
         return { ok: true };
     }
     providerReplyTo(msg) {
-        return msg.replyTo ?? msg.id;
+        return pickReplyToTarget(msg);
     }
     emitInbound(turnId, msg) {
         if (!this.transcript.enabled)

package/dist/gateway/runtimes/deepseek-tui.js

@@ -426,8 +426,12 @@ function isDeepseekTerminalEvent(eventName, payload) {
         embedded === "done");
 }
 function isToolStarted(eventName, payload) {
+    const itemKind = payload?.payload?.item?.kind ?? payload?.item?.kind;
     return ((eventName === "item.started" &&
-        (!!payload?.tool || payload?.item?.kind === "tool_call" || payload?.payload?.item?.kind === "tool_call")) ||
+        (!!payload?.tool ||
+            itemKind === "tool_call" ||
+            itemKind === "command_execution" ||
+            itemKind === "file_change")) ||
         (payload?.event === "item.started" && !!payload?.payload?.tool));
 }
 function isToolCompleted(eventName, payload) {

package/dist/index.js

@@ -5,7 +5,7 @@ import { homedir, hostname } from "node:os";
 import path from "node:path";
 import { augmentProcessPath } from "./path-env.js";
 import { loadConfig, saveConfig, initDefaultConfig, resolveConfiguredAgentIds, SNAPSHOT_PATH, CONFIG_FILE_PATH, CONFIG_MISSING, } from "./config.js";
-import { ensureNoOtherDaemonFromPidFile, findOtherDaemonProcesses, pidAlive, readPid, removePidFile, stopDaemonFromPidFileForRestart, stopOtherDaemonProcessesForRestart, writeCurrentPid, } from "./daemon-singleton.js";
+import { acquireDaemonSingletonLock, ensureNoOtherDaemonFromPidFile, findOtherDaemonProcesses, pidAlive, readPid, removePidFile, stopDaemonFromPidFileForRestart, stopOtherDaemonProcessesForRestart, writeCurrentPid, } from "./daemon-singleton.js";
 import { resolveBootAgents } from "./agent-discovery.js";
 import { defaultTranscriptRoot, resolveTranscriptEnabled, transcriptAgentRoot, transcriptFilePath, } from "./gateway/index.js";
 import { startDaemon } from "./daemon.js";
@@ -506,12 +506,22 @@ async function cmdStart(args) {
         return;
     }
     // Foreground: we ARE the daemon.
+    const singletonLock = await acquireDaemonSingletonLock({ logger: log });
     writeCurrentPid();
-    const handle = await startDaemon({ config: cfg, configPath: CONFIG_FILE_PATH });
+    let handle;
+    try {
+        handle = await startDaemon({ config: cfg, configPath: CONFIG_FILE_PATH });
+    }
+    catch (err) {
+        removePidFile();
+        singletonLock.release();
+        throw err;
+    }
     const shutdown = async (sig) => {
         log.info("signal received", { sig });
         await handle.stop(sig);
         removePidFile();
+        singletonLock.release();
         process.exit(0);
     };
     process.on("SIGTERM", () => shutdown("SIGTERM"));
@@ -539,6 +549,7 @@ async function cmdStartCloud(_args) {
         daemonInstanceId: cloudConfig.daemonInstanceId,
         hubUrl: cloudConfig.hubUrl,
     });
+    const singletonLock = await acquireDaemonSingletonLock({ logger: log });
     await stopDaemonFromPidFileForRestart({ logger: log });
     await stopOtherDaemonProcessesForRestart({ logger: log });
     writeCurrentPid();
@@ -552,15 +563,24 @@ async function cmdStartCloud(_args) {
     };
     saveConfig(cfg);
     log.info("cloud mode config initialized", { configPath: CONFIG_FILE_PATH });
-    const handle = await startCloudDaemon({
-        cloudConfig,
-        config: cfg,
-        configPath: CONFIG_FILE_PATH,
-    });
+    let handle;
+    try {
+        handle = await startCloudDaemon({
+            cloudConfig,
+            config: cfg,
+            configPath: CONFIG_FILE_PATH,
+        });
+    }
+    catch (err) {
+        removePidFile();
+        singletonLock.release();
+        throw err;
+    }
     const shutdown = async (sig) => {
         log.info("signal received", { sig });
         await handle.stop(sig);
         removePidFile();
+        singletonLock.release();
         process.exit(0);
     };
     process.on("SIGTERM", () => void shutdown("SIGTERM"));

package/dist/provision.js

@@ -7,7 +7,7 @@
 import { existsSync, lstatSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { BotCordClient, CONTROL_FRAME_TYPES, defaultCredentialsFile, derivePublicKey, loadStoredCredentials, writeCredentialsFile, } from "@botcord/protocol-core";
+import { BotCordClient, CONTROL_FRAME_TYPES, defaultCredentialsFile, derivePublicKey, loadStoredCredentials, normalizeTokenExpiresAt, 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";
@@ -19,8 +19,14 @@ import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
 import { resolveMemoryDir } from "./working-memory.js";
 import { discoverRuntimeModelCatalog } from "./runtime-models.js";
+import { collectAgentSkillSnapshot } from "./skill-index.js";
 import { buildRuntimeSelectionExtraArgs, mergeRuntimeExtraArgs, } from "./runtime-route-options.js";
 import { handleCloudGatewayRuntimeInbound, } from "./cloud-gateway-runtime.js";
+function runtimeForLoadedAgent(gateway, agentId) {
+    return gateway.listManagedRoutes()
+        .find((route) => route.match?.accountId === agentId)
+        ?.runtime;
+}
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
  * handler. Returned function signature matches
@@ -315,6 +321,33 @@ export function createProvisioner(opts) {
                 });
                 return { ok: true, result };
             }
+            case "list_agent_skills": {
+                const params = (frame.params ?? {});
+                if (!params.agentId) {
+                    return {
+                        ok: false,
+                        error: { code: "bad_params", message: "list_agent_skills requires params.agentId" },
+                    };
+                }
+                const channels = gateway.snapshot().channels;
+                if (!channels[params.agentId]) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "agent_not_loaded",
+                            message: `agent ${params.agentId} is not loaded in daemon gateway`,
+                        },
+                    };
+                }
+                const runtime = runtimeForLoadedAgent(gateway, params.agentId);
+                const result = collectAgentSkillSnapshot(params.agentId, { runtime });
+                daemonLog.debug("list_agent_skills", {
+                    agentId: params.agentId,
+                    runtime,
+                    count: result.skills.length,
+                });
+                return { ok: true, result };
+            }
             case "wake_agent": {
                 return handleWakeAgent(gateway, frame.params);
             }
@@ -921,8 +954,9 @@ async function materializeCredentials(params, cfg, ctx, explicitCwd) {
             record.displayName = c.displayName;
         if (c.token)
             record.token = c.token;
-        if (typeof c.tokenExpiresAt === "number")
-            record.tokenExpiresAt = c.tokenExpiresAt;
+        const tokenExpiresAt = normalizeTokenExpiresAt(c.tokenExpiresAt);
+        if (tokenExpiresAt !== undefined)
+            record.tokenExpiresAt = tokenExpiresAt;
         if (runtime)
             record.runtime = runtime;
         const runtimeSelection = pickRuntimeSelection(params);