@nowcrew/daemon 0.5.28 → 0.5.30

package/dist/serve.js

@@ -0,0 +1,868 @@
+/**
+ * 常驻模式 (M3c):连接 server 控制面 WS,注册机器,监听 agent:start 自动唤醒 agent。
+ * 断线指数退避重连。一个 agent:start 进来就跑一次现有的 runAgent。
+ */
+import { WebSocket } from "ws";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
+import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
+import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
+import { collectMachineHello, DAEMON_CAPABILITIES, EXECUTION_PROTOCOL, } from "./machine-info.js";
+import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
+import { listSkills } from "./skills.js";
+import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
+import { listRuntimeModels } from "./list-models.js";
+import { normalizeScheduledContext } from "./scheduled-report.js";
+import { formatDaemonLogLine } from "./log-format.js";
+import { reportAgentRunComplete } from "./scheduled-run-report.js";
+import { runWithOriginDecisionGuard } from "./origin-decision.js";
+import { createExecutionJournal } from "./execution-journal.js";
+import { createExecutionTelemetryJournal } from "./execution-telemetry-journal.js";
+import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
+import { hashExecutionSpec, runExecution, } from "./execution-runner.js";
+import { executionBackendCapability } from "./execution-backend.js";
+import { awaitWithCancellation, createRuntimeCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
+import { createShutdownDeadline, readTestShutdownConfiguration } from "./shutdown-deadline.js";
+import { closeWebSocketWithinDeadline } from "./websocket-shutdown.js";
+import { reconcileExecutionJournal } from "./execution-recovery.js";
+import { createSharedSlotManager } from "./shared-execution-slots.js";
+import { createCompletionRetransmitter } from "./completion-retransmitter.js";
+// normalize.ts 的活动种类 → activity 枚举
+const ACTIVITY_MAP = {
+    init: "working", text: "thinking", reading: "reading", sending: "sending",
+    checking: "checking", claiming: "claiming", crew: "working", tool: "working",
+    tool_result: "working", done: "done", error: "error",
+};
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe) {
+    const query = new URLSearchParams({ key: machineToken });
+    if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
+        query.set("execution_min", String(EXECUTION_PROTOCOL.min));
+        query.set("execution_max", String(EXECUTION_PROTOCOL.max));
+    }
+    for (const capability of DAEMON_CAPABILITIES)
+        query.append("capability", capability);
+    return `${serverUrl.replace(/^http/, "ws").replace(/\/+$/, "")}/daemon/connect?${query.toString()}`;
+}
+export function serve(config, opts = {}) {
+    const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken);
+    let stopped = false;
+    let ws = null;
+    let backoff = 1000;
+    const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    const testShutdown = readTestShutdownConfiguration(process.env);
+    const shutdownTimeoutMs = opts.shutdownTimeoutMs ?? testShutdown.timeoutMs ?? 30_000;
+    const createWebSocket = opts.createWebSocket ?? ((url) => new WebSocket(url));
+    let reconnectTimer = null;
+    let stopPromise = null;
+    const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
+    const executionTelemetry = createExecutionTelemetryJournal(config.agentsRoot);
+    const executeProtocol = opts.execution?.runExecution ?? runExecution;
+    let detectedExecutionRuntimes = [];
+    let runtimeFacts = null;
+    const sharedSlots = createSharedSlotManager(config.executionLimits);
+    const knownExecutionHashes = new Map();
+    const executionReservations = new Map();
+    const executionRuns = new Map();
+    let executionFrameQueue = Promise.resolve();
+    const cancellations = new Map();
+    const legacyRuns = new Map();
+    const safeExecutionSend = (frame) => {
+        try {
+            if (ws?.readyState !== WebSocket.OPEN)
+                return false;
+            ws.send(JSON.stringify(frame));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const completionRetransmitter = createCompletionRetransmitter({
+        send: safeExecutionSend,
+        ...(opts.execution?.completionRetryDelaysMs === undefined ? {} : {
+            retryDelaysMs: opts.execution.completionRetryDelaysMs,
+        }),
+        onAttempt: ({ kind, executionId, attempt, nextDelayMs }) => {
+            dslog(kind === "sent" ? "execution.completion_sent" : "execution.completion_retried", kind === "sent" ? "execution completion 已发送" : "execution completion 未确认,已重传", { execution_id: executionId, attempt, next_delay_ms: nextDelayMs });
+        },
+    });
+    const reportExecutionFrame = async (frame) => {
+        if (frame.type === "execution:activity" || frame.type === "execution:console") {
+            try {
+                await executionTelemetry.append(frame);
+            }
+            catch (error) {
+                dslog("execution.telemetry_journal_failed", "execution telemetry 持久化失败", {
+                    level: "ERROR", execution_id: frame.executionId,
+                    error_message: error.message,
+                });
+                throw error;
+            }
+        }
+        if (frame.type === "execution:completed") {
+            completionRetransmitter.track(frame);
+            return;
+        }
+        safeExecutionSend(frame);
+    };
+    const replayExecutionTelemetry = async () => {
+        const frames = await executionTelemetry.replay();
+        for (const frame of frames)
+            safeExecutionSend(frame);
+    };
+    const snapshotEntry = (entry) => {
+        if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
+            return { executionId: entry.executionId, state: entry.state, completion: entry.completion, updatedAt: entry.updatedAt };
+        }
+        if (entry.state === "accepted" || entry.state === "running") {
+            return { executionId: entry.executionId, state: entry.state, updatedAt: entry.updatedAt };
+        }
+        return null;
+    };
+    const sendSnapshot = async (reqId) => {
+        const entries = (await executionJournal.replay()).map(snapshotEntry).filter((entry) => entry !== null);
+        safeExecutionSend(ExecutionSnapshotSchema.parse({
+            type: "execution:snapshot", protocolVersion: 1, reqId, entries,
+        }));
+    };
+    const sendJournalStatus = (entry, acceptanceState = "ready") => {
+        if ((entry.state === "completed" || entry.state === "interrupted") && entry.completion !== null) {
+            completionRetransmitter.track(entry.completion);
+            return;
+        }
+        if (entry.state === "accepted" || entry.state === "running") {
+            safeExecutionSend({
+                type: "execution:accepted", protocolVersion: 1, executionId: entry.executionId,
+                state: acceptanceState, effectivePermission: entry.effectivePermission ?? "workspace_write",
+                at: entry.acceptedAt,
+            });
+            if (entry.state === "running" && entry.processStartedAt !== null) {
+                safeExecutionSend({
+                    type: "execution:started", protocolVersion: 1,
+                    executionId: entry.executionId, at: entry.processStartedAt,
+                });
+            }
+        }
+    };
+    const cancellationFor = (executionId) => {
+        const existing = cancellations.get(executionId);
+        if (existing !== undefined)
+            return existing.cancellation;
+        const controller = createRuntimeCancellation();
+        cancellations.set(executionId, controller);
+        return controller.cancellation;
+    };
+    const requestCancellation = (executionId) => {
+        cancellationFor(executionId);
+        cancellations.get(executionId).request();
+        const reservation = executionReservations.get(executionId);
+        if (reservation?.isQueued())
+            reservation.release();
+    };
+    let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
+    initSlog(config.serverUrl, config.machineToken);
+    dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
+    // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
+    // scheduled 重复 run 仍由 running 去重;普通同线程 wake 用 legacyTaskTails 串成 FIFO。
+    // 每 agent 超过并行上限的任务继续进入 sharedQueues(不丢)。
+    const running = new Set();
+    const legacyTaskTails = new Map();
+    const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
+    function connect() {
+        if (stopped)
+            return;
+        ws = createWebSocket(wsUrl);
+        ws.on("open", () => {
+            const openedSocket = ws;
+            backoff = 1000;
+            connectedAt = Date.now();
+            log(`🔌 已连接控制面 ${config.serverUrl}`);
+            dslog("daemon.ws_open", "已连接控制面", { server_url: config.serverUrl });
+            // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
+            void drainSpool();
+            // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
+            const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits);
+            runtimeFacts = helloPromise.then((hello) => hello.executionRuntimes, (error) => {
+                dslog("execution.runtime_detection_failed", "runtime 探测失败", {
+                    level: "ERROR", error_message: error.message,
+                });
+                return [];
+            });
+            void helloPromise
+                .then((hello) => {
+                detectedExecutionRuntimes = hello.executionRuntimes;
+                try {
+                    ws?.send(JSON.stringify(hello));
+                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
+                }
+                catch { /* 非 OPEN,忽略 */ }
+            })
+                .catch(() => { });
+            opts.onOpen?.(ws);
+            void sendSnapshot(`reconnect-${randomUUID()}`);
+            void executionJournal.replay()
+                .then((entries) => {
+                for (const entry of entries) {
+                    if ((entry.state === "completed" || entry.state === "interrupted")
+                        && !entry.completionAcknowledged
+                        && entry.completion !== null) {
+                        completionRetransmitter.track(entry.completion);
+                    }
+                }
+            })
+                .catch((error) => {
+                dslog("execution.completion_replay_failed", "execution completion 重放失败", {
+                    level: "ERROR", error_message: error.message,
+                });
+            })
+                .finally(() => {
+                if (ws === openedSocket && openedSocket?.readyState === WebSocket.OPEN) {
+                    completionRetransmitter.resume();
+                }
+            });
+            void replayExecutionTelemetry().catch((error) => {
+                dslog("execution.telemetry_replay_failed", "execution telemetry 重放失败", {
+                    level: "ERROR", error_message: error.message,
+                });
+            });
+        });
+        ws.on("message", async (data) => {
+            if (stopped)
+                return;
+            let decoded;
+            try {
+                decoded = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (typeof decoded !== "object" || decoded === null)
+                return;
+            const rawType = "type" in decoded && typeof decoded.type === "string" ? decoded.type : "";
+            if (rawType.startsWith("execution:")) {
+                const parsedExecution = ServerToDaemonExecutionFrameSchema.safeParse(decoded);
+                if (!parsedExecution.success) {
+                    const executionId = "executionId" in decoded && typeof decoded.executionId === "string"
+                        ? decoded.executionId
+                        : null;
+                    if (executionId !== null) {
+                        const rejected = ExecutionRejectedSchema.safeParse({
+                            type: "execution:rejected", protocolVersion: 1, executionId,
+                            reason: "invalid_spec", message: parsedExecution.error.issues[0]?.message,
+                            at: new Date().toISOString(),
+                        });
+                        if (rejected.success)
+                            safeExecutionSend(rejected.data);
+                    }
+                    return;
+                }
+                const frame = parsedExecution.data;
+                executionFrameQueue = executionFrameQueue.then(async () => {
+                    if (stopped)
+                        return;
+                    if (frame.type === "execution:completion-ack") {
+                        try {
+                            await executionJournal.acknowledgeCompletion(frame.executionId);
+                            const attempts = completionRetransmitter.acknowledge(frame.executionId);
+                            dslog("execution.completion_acknowledged", "execution completion ACK 已持久化", {
+                                execution_id: frame.executionId,
+                                attempts,
+                            });
+                        }
+                        catch (error) {
+                            dslog("execution.completion_ack_failed", "execution completion ACK 持久化失败", {
+                                level: "ERROR",
+                                execution_id: frame.executionId,
+                                error_message: error.message,
+                            });
+                        }
+                        return;
+                    }
+                    if (frame.type === "execution:event-ack") {
+                        await executionTelemetry.acknowledge(frame.executionId, frame.kind, frame.seq).catch((error) => {
+                            dslog("execution.telemetry_ack_failed", "execution telemetry ACK 处理失败", {
+                                level: "ERROR", execution_id: frame.executionId,
+                                error_message: error.message,
+                            });
+                        });
+                        return;
+                    }
+                    if (frame.type === "execution:cancel") {
+                        if (!knownExecutionHashes.has(frame.executionId)
+                            && !executionRuns.has(frame.executionId)
+                            && await executionJournal.get(frame.executionId) === null)
+                            return;
+                        requestCancellation(frame.executionId);
+                        return;
+                    }
+                    if (frame.type === "execution:sync") {
+                        await sendSnapshot(frame.reqId);
+                        return;
+                    }
+                    const spec = frame;
+                    const hash = hashExecutionSpec(spec);
+                    const knownHash = knownExecutionHashes.get(spec.executionId);
+                    if (knownHash !== undefined) {
+                        if (knownHash !== hash) {
+                            safeExecutionSend(ExecutionRejectedSchema.parse({
+                                type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                                reason: "invalid_spec", message: "executionId already has a different spec",
+                                at: new Date().toISOString(),
+                            }));
+                            return;
+                        }
+                        const existing = await executionJournal.get(spec.executionId);
+                        if (existing !== null) {
+                            const state = executionReservations.get(spec.executionId)?.isQueued() ? "queued" : "ready";
+                            sendJournalStatus(existing, state);
+                        }
+                        return;
+                    }
+                    const durableExisting = await executionJournal.get(spec.executionId);
+                    if (stopped)
+                        return;
+                    if (durableExisting !== null) {
+                        if (durableExisting.specHash !== hash) {
+                            safeExecutionSend(ExecutionRejectedSchema.parse({
+                                type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                                reason: "invalid_spec", message: "executionId already has a different spec",
+                                at: new Date().toISOString(),
+                            }));
+                        }
+                        else {
+                            sendJournalStatus(durableExisting);
+                        }
+                        return;
+                    }
+                    knownExecutionHashes.set(spec.executionId, hash);
+                    const reservation = sharedSlots.reserve(spec.agent.handle, "execution");
+                    executionReservations.set(spec.executionId, reservation);
+                    const cancellation = cancellationFor(spec.executionId);
+                    const cleanupExecutionReservation = () => {
+                        reservation.release();
+                        cancellations.delete(spec.executionId);
+                        executionReservations.delete(spec.executionId);
+                        knownExecutionHashes.delete(spec.executionId);
+                    };
+                    let availableRuntimes;
+                    try {
+                        availableRuntimes = opts.execution?.availableRuntimes?.()
+                            ?? await (runtimeFacts ?? Promise.resolve(detectedExecutionRuntimes));
+                    }
+                    catch (error) {
+                        cleanupExecutionReservation();
+                        safeExecutionSend(ExecutionRejectedSchema.parse({
+                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                            reason: "resource_limit", message: `Runtime detection failed: ${error.message}`,
+                            at: new Date().toISOString(),
+                        }));
+                        return;
+                    }
+                    if (stopped) {
+                        cleanupExecutionReservation();
+                        return;
+                    }
+                    const execution = executeProtocol(config, spec, {
+                        ...opts.execution?.dependencies,
+                        journal: executionJournal,
+                        facts: {
+                            availableRuntimes,
+                            ...reservation.facts,
+                        },
+                        report: reportExecutionFrame,
+                        ...(reservation.state === undefined ? {} : {
+                            slot: { state: reservation.state, ready: reservation.ready },
+                        }),
+                        cancellation,
+                    }).finally(() => {
+                        cleanupExecutionReservation();
+                        executionRuns.delete(spec.executionId);
+                    });
+                    executionRuns.set(spec.executionId, execution);
+                    void execution.catch(() => { });
+                    return;
+                }).catch((error) => {
+                    dslog("execution.frame_failed", "execution 控制帧处理失败", {
+                        level: "ERROR", error_message: error.message,
+                    });
+                });
+                return;
+            }
+            const legacy = typeof decoded === "object" && decoded !== null
+                && "type" in decoded && decoded.type === "agent:start"
+                ? LegacyAgentStartSchema.safeParse(decoded)
+                : null;
+            if (legacy !== null && !legacy.success) {
+                // 帧结构不合法(如 server 端已升级到 execution v1 但本 daemon 仍按 legacy 校验)。
+                // 曾经静默 return——只表现为"@了 agent 没反应",且完全没有排查线索。记录字段路径和
+                // zod 错误码,不记录消息正文/附件等可能敏感的字段值。
+                const raw = decoded;
+                dslog("run.legacy_frame_rejected", "agent:start 帧未通过 legacy schema 校验,已丢弃", {
+                    level: "WARN",
+                    agent_handle: typeof raw.agentHandle === "string" ? raw.agentHandle : undefined,
+                    channel_id: typeof raw.channelId === "string" ? raw.channelId : undefined,
+                    reason: typeof raw.reason === "string" ? raw.reason : undefined,
+                    issue_count: legacy.error.issues.length,
+                    issue_paths: legacy.error.issues
+                        .map((issue) => `${issue.path.join(".")}:${issue.code}`)
+                        .join(","),
+                });
+                return;
+            }
+            const msg = (legacy?.success ? legacy.data : decoded);
+            // 控制面鉴权拒绝:server 端 resolveToken 未命中有效的 machine 凭证(失效/被吊销/
+            // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
+            // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
+            // 需在 NowWork 重新 Add Computer 拿新连接命令)。
+            if (msg.type === "ready") {
+                // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
+                const r = msg;
+                setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                return;
+            }
+            if (msg.type === "error") {
+                if (msg.code === "UNAUTHENTICATED") {
+                    log(`🛑 控制面拒绝鉴权:机器凭证无效或已吊销 (UNAUTHENTICATED)。`);
+                    log(`   请在 NowWork 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
+                    dslog("daemon.ws_auth_rejected", "控制面拒绝鉴权:机器凭证无效或已吊销", { level: "ERROR" });
+                    backoff = maxBackoff; // 退避到最大,停止每秒重连刷屏
+                }
+                return;
+            }
+            // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
+            if (msg.type === "raft:inspect" || msg.type === "raft:import") {
+                const req = msg;
+                const reply = (r) => {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", reqId: req.reqId, ...r }));
+                    }
+                    catch { /* 忽略 */ }
+                };
+                try {
+                    const data2 = req.type === "raft:inspect"
+                        ? await inspectRaftWorkspace(req.path)
+                        : await importRaftWorkspace(req.path, join(config.agentsRoot, req.handle));
+                    if (req.type === "raft:import") {
+                        log(`📦 已导入 raft 工作区 → ${req.handle}: 复制 ${data2.copied.length} 项`);
+                    }
+                    reply({ ok: true, data: data2 });
+                }
+                catch (e) {
+                    reply({ ok: false, error: e.message });
+                }
+                return;
+            }
+            // workspace 文件浏览 / skills 枚举请求 (只读、沙箱;见 workspace-fs.ts / skills.ts)
+            if (msg.type === "fs:list" || msg.type === "fs:read" || msg.type === "skills:list" || msg.type === "probe-models") {
+                const req = msg;
+                const root = join(config.agentsRoot, req.handle);
+                const reply = (r) => {
+                    try {
+                        ws?.send(JSON.stringify({ type: "fs:result", reqId: req.reqId, ...r }));
+                    }
+                    catch { /* 忽略 */ }
+                };
+                try {
+                    const data2 = req.type === "fs:list" ? await listWorkspace(root, req.path)
+                        : req.type === "fs:read" ? await readWorkspaceFile(root, req.path)
+                            : req.type === "skills:list" ? await listSkills(config.agentsRoot, req.handle)
+                                : { models: await listRuntimeModels(req.type === "probe-models" ? (req.runtime ?? "") : "") };
+                    reply({ ok: true, data: data2 });
+                }
+                catch (e) {
+                    reply({ ok: false, error: e.message });
+                }
+                return;
+            }
+            if (msg.type !== "agent:start")
+                return; // ready/error 等忽略
+            // 任务键:scheduled run 用 runId(每次运行独立 cwd/work-log;overlap 由 server 端 skip_if_running 管,
+            // daemon 的 running 去重只兜底"同一 run 重复投递");普通唤醒仍是 线程锚点 ?? 频道。
+            const scheduled = msg.reason === "scheduled_job" && msg.scheduledRun
+                ? normalizeScheduledContext({
+                    jobId: msg.scheduledRun.jobId,
+                    runId: msg.scheduledRun.runId,
+                    ...(typeof msg.scheduledRun.title === "string" ? { title: msg.scheduledRun.title } : {}),
+                    ...(msg.scheduledRun.outputPolicy !== undefined
+                        ? { outputPolicy: msg.scheduledRun.outputPolicy }
+                        : {}),
+                    ...(msg.scheduledRun.externalNotificationPolicy !== undefined
+                        ? { externalNotificationPolicy: msg.scheduledRun.externalNotificationPolicy }
+                        : {}),
+                })
+                : null;
+            const threadId = msg.wake?.threadId;
+            const taskKey = scheduled ? scheduled.runId : (threadId ?? msg.channelId);
+            const key = `${msg.agentHandle}:${taskKey}`;
+            // run_id 贯穿本轮全链路(wake→start→resume 决策→end),SLS 按 run_id 一查即得单轮时间线
+            const runId = randomUUID();
+            const runKeys = {
+                run_id: runId, agent_handle: msg.agentHandle, channel_id: msg.channelId,
+                thread_id: threadId ?? null, task_key: taskKey,
+            };
+            dslog("run.wake_received", `收到唤醒 ${msg.agentHandle}`, {
+                ...runKeys, reason: msg.reason ?? "", sender: msg.wake?.senderHandle,
+                wake_origin: msg.wake?.origin ?? null,
+                content_preview: (msg.wake?.content ?? "").replace(/\s+/g, " ").slice(0, 120),
+            });
+            if (scheduled && running.has(key)) {
+                log(`↩︎ 跳过(该任务已在运行): ${key}`);
+                dslog("run.dedupe_skip", "跳过唤醒:该任务已在运行", { level: "WARN", ...runKeys });
+                return;
+            }
+            const queueWaitStart = Date.now();
+            const runStartedAt = Date.now();
+            const controller = createRuntimeCancellation();
+            let finishLegacyRun;
+            let failLegacyRun;
+            const legacyDone = new Promise((resolveDone, rejectDone) => {
+                finishLegacyRun = resolveDone;
+                failLegacyRun = rejectDone;
+            });
+            void legacyDone.catch(() => undefined);
+            legacyRuns.set(runId, { controller, done: legacyDone });
+            let legacyStopError;
+            let legacyReservation = null;
+            let legacyQueueDone = null;
+            let finishLegacyQueue = () => { };
+            try {
+                if (!scheduled) {
+                    const previous = legacyTaskTails.get(key);
+                    legacyQueueDone = new Promise((resolve) => { finishLegacyQueue = resolve; });
+                    legacyTaskTails.set(key, legacyQueueDone);
+                    if (previous) {
+                        log(`⏳ 排队(该任务已在运行): ${key}`);
+                        dslog("run.wake_queued", "唤醒已排队:该任务正在运行", { ...runKeys });
+                        await awaitWithCancellation(previous, controller.cancellation);
+                    }
+                }
+                running.add(key);
+                legacyReservation = sharedSlots.reserve(msg.agentHandle, "legacy");
+                await awaitWithCancellation(legacyReservation.ready, controller.cancellation);
+                const queueMs = Date.now() - queueWaitStart;
+                const threadLabel = threadId ?? null;
+                const from = msg.wake?.senderHandle ?? "?";
+                const incoming = msg.wake?.content ?? "";
+                dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+                log(`\n${"─".repeat(56)}`);
+                log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
+                log(`   channel = ${msg.channelId}`);
+                log(`   thread  = ${threadLabel ? `${threadLabel} (要求线程内回复)` : "(无,顶层回复)"}`);
+                if (incoming)
+                    log(`📥 来信 @${from}: ${incoming.replace(/\s+/g, " ").slice(0, 200)}`);
+                let actSeq = 0;
+                const reportActivity = (a) => {
+                    const det = a.detail ? a.detail.replace(/\s+/g, " ").trim() : "";
+                    // 发消息时尽量打印回复正文/目标(--content "..." 或 heredoc 首行)
+                    let line = `  · ${a.label}`;
+                    if (a.kind === "sending") {
+                        const m = det.match(/--content\s+"([^"]*)"/) || det.match(/<<'?\w+'?\s*(.*)/);
+                        line = `  💬 回复${threadLabel ? `(thread ${threadLabel})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
+                    }
+                    else if (det) {
+                        line += ` ${det.slice(0, 80)}`;
+                    }
+                    log(line);
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:activity",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            activity: ACTIVITY_MAP[a.kind] ?? "working",
+                            detail: a.detail || a.label,
+                            seq: actSeq++,
+                        }));
+                    }
+                    catch { /* ws 非 OPEN,忽略 */ }
+                };
+                // 终端透传:把底层 claude 的每条 console 行按线程上送给 server(独立 seq,落库+广播给 web 终端窗口)。
+                let conSeq = 0;
+                const reportConsole = (c) => {
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:console",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            threadId: threadId ?? null,
+                            stream: c.stream,
+                            text: c.text,
+                            // 结构化负载(diff/命令/todo…):前端富渲染用;缺省 = 纯文本行
+                            ...(c.payload !== undefined ? { payload: c.payload } : {}),
+                            seq: conSeq++,
+                        }));
+                    }
+                    catch { /* ws 非 OPEN,忽略 */ }
+                };
+                // 线程聚合:触发消息即任务线程根,你的确认+后续所有回复都要发到它的线程里,
+                // 不要发顶层——这样 task 讨论全部聚合在该 thread 下。
+                const threadHint = threadId
+                    ? `\n**所有回复都必须发到这条消息的线程里**(任务线程):用 crew message send --channel ${msg.channelId} --thread ${threadId} 发送,不要发频道顶层。`
+                    : "";
+                // channel(广播投递):你是频道成员之一,自己判断是否与你职责相关——相关才行动(回复 /
+                // crew task create / claim / 交接给下一棒),不相关就不回(频道沉默不算失败,避免人人都答)。
+                const reasonHint = msg.reason === "channel"
+                    ? `\n这是频道里的新消息(广播给频道成员)。**先判断是否属于你的职责**:与你无关就直接结束、不要回复(频道沉默不算失败);相关才接手。`
+                    : "";
+                // 关键协作礼仪:一旦决定接手,先在线程回应一声,别让频道空着干等;但确认措辞要与
+                // 系统提示词「对人说话/沟通风格」一致——日常语言带理解/方向,不写 task #N 等协议词,
+                // 写不出实质内容就并进第一条进展(此处若强制"收到+task #N"会把系统提示词顶掉)。
+                const sendCmd = threadId
+                    ? `crew message send --channel ${msg.channelId} --thread ${threadId}`
+                    : `crew message send --channel ${msg.channelId}`;
+                const ackHint = `\n**协作礼仪:决定接手后,先用 \`${sendCmd}\` 在该任务线程说一声你来跟进**——用日常语言带上你对问题的理解或打算先查什么,不要写"我接 task #N"这类内部编号;写不出实质内容就不单发,并进第一条实质进展,但不要长时间闷头干活把线程空着。`;
+                // 图片/文件附件:crew message read 会在消息下列出附件及其 id;图片需下载后用 Read 工具查看,才能真正"看到"内容。
+                const attHint = `\n若消息带图片/文件附件(read 会列出 id),用 \`crew attachment get <id>\` 下载到本地,图片再用 Read 工具打开查看后再处理。`;
+                // 线程隔离:有 threadId 时用 `crew thread read` 只读本线程(避免被其他线程消息干扰);
+                // 顶层消息(无 threadId)用 `crew message read` 读整个频道。
+                const readCmd = threadId
+                    ? `crew thread read`
+                    : `crew message read --channel ${msg.channelId}`;
+                const wakeText = scheduled
+                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy, scheduled.externalNotificationPolicy)
+                    : (msg.wake?.content
+                        ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
+                        : undefined);
+                const wakeOrigin = scheduled ? undefined : msg.wake?.origin;
+                const guarded = await runWithOriginDecisionGuard(wakeOrigin, async (attempt) => {
+                    if (attempt === 1) {
+                        dslog("run.origin_decision_retry", "Agent 未完成企微回复决策，补跑一次", {
+                            level: "WARN", ...runKeys, wake_origin: wakeOrigin,
+                        });
+                    }
+                    const attemptWake = attempt === 1
+                        ? buildOriginDecisionRetryPrompt(msg.channelId, threadId)
+                        : wakeText;
+                    return runAgent(config, {
+                        handle: msg.agentHandle,
+                        channelId: msg.channelId,
+                        taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
+                        runId, // 贯穿 SLS 日志的单轮关联键
+                        ...(scheduled ? {
+                            scheduled: {
+                                title: scheduled.title,
+                                outputPolicy: scheduled.outputPolicy,
+                                externalNotificationPolicy: scheduled.externalNotificationPolicy,
+                            },
+                        } : {}),
+                        ...(wakeOrigin ? { wakeOrigin, originDecisionAttempt: attempt } : {}),
+                        // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
+                        ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
+                        ...(!scheduled && msg.wake?.seq !== undefined ? { wakeContextUpToSeq: msg.wake.seq } : {}),
+                        ...(attemptWake ? { wake: attemptWake } : {}),
+                    }, reportActivity, reportConsole, { cancellation: controller.cancellation });
+                });
+                const result = mergeRunAgentResults(guarded.results);
+                // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
+                // 连同模型/runtime 一起上送控制面落库 → 支撑每 agent / 每任务(线程)的用量监控与成本核算。
+                if (result.usage) {
+                    const u = result.usage;
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:usage",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            threadId: threadId ?? null, // 线程根消息 id(= 任务锚点);null = 频道级唤醒
+                            runtime: result.runtime,
+                            model: result.model,
+                            resumed: result.resumed,
+                            inputTokens: u.inputTokens,
+                            outputTokens: u.outputTokens,
+                            cacheReadTokens: u.cacheReadTokens,
+                            cacheCreationTokens: u.cacheCreationTokens,
+                            ...(u.costUsd != null ? { costUsd: u.costUsd } : {}),
+                        }));
+                    }
+                    catch { /* ws 非 OPEN,忽略(用量非关键路径,丢一轮不阻塞) */ }
+                }
+                // 所有 run 都上报完成边界:普通交互用于企微单轮聚合;scheduled 继续驱动 run/job 落库。
+                reportAgentRunComplete(ws?.readyState === WebSocket.OPEN ? ws : null, {
+                    runId,
+                    agentHandle: msg.agentHandle,
+                    channelId: msg.channelId,
+                    threadId: threadId ?? null,
+                    exitCode: result.exitCode,
+                    runtime: result.runtime,
+                    model: result.model,
+                    resumed: result.resumed,
+                    usage: result.usage,
+                    ...(wakeOrigin ? {
+                        wakeOrigin,
+                        originDecision: result.originDecision ?? "missing",
+                        ...(msg.wake?.seq !== undefined ? { contextUpToSeq: msg.wake.seq } : {}),
+                    } : {}),
+                    ...(scheduled ? { scheduledRunId: scheduled.runId } : {}),
+                    ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+                    ...(result.report ? { report: result.report } : {}),
+                }, dslog);
+                // run.end 是排查「任务没跑完就本轮结束」的核心证据:退出码 + 时长 + 最后活动 +
+                // 是否 resume + 用量。exit_code!=0 或时长异常短都值得追。
+                const lastActivity = result.activities.length
+                    ? result.activities[result.activities.length - 1].kind
+                    : null;
+                dslog("run.end", `本轮结束 ${msg.agentHandle} (exit=${result.exitCode})`, {
+                    ...runKeys,
+                    level: result.exitCode === 0 ? "INFO" : "ERROR",
+                    exit_code: result.exitCode, duration_ms: Date.now() - runStartedAt,
+                    runtime: result.runtime, model: result.model, resumed: result.resumed,
+                    session_id: result.sessionId,
+                    activity_count: result.activities.length, last_activity: lastActivity,
+                    wake_origin: wakeOrigin ?? null,
+                    origin_decision: result.originDecision ?? null,
+                    ...(result.usage ? {
+                        tokens_input: result.usage.inputTokens, tokens_output: result.usage.outputTokens,
+                        cache_read: result.usage.cacheReadTokens, cache_creation: result.usage.cacheCreationTokens,
+                        ...(result.usage.costUsd != null ? { cost_usd: result.usage.costUsd } : {}),
+                    } : {}),
+                });
+                if (result.exitCode === 0) {
+                    reportActivity({ kind: "done", label: "本轮结束" });
+                    reportConsole({ stream: "result", text: "● 本轮结束" });
+                    log(`✅ agent=${msg.agentHandle} 本轮完成`);
+                }
+                else {
+                    // 非零退出不能谎报「本轮结束」。runner 已对 codex/kimi 上报带 stderr 的 error 活动,
+                    // 这里只兜底(如 claude 崩溃)并让终态落在 error 上。
+                    if (!result.activities.some((a) => a.kind === "error")) {
+                        reportActivity({ kind: "error", label: "运行出错", detail: `${result.runtime} 退出码 ${result.exitCode}` });
+                    }
+                    reportConsole({ stream: "error", text: `✖ 运行出错 (exit ${result.exitCode})` });
+                    log(`❌ agent=${msg.agentHandle} 本轮失败 (exit ${result.exitCode})`);
+                }
+            }
+            catch (e) {
+                if (controller.cancellation.isRequested() && !(e instanceof RuntimeCancelledError)) {
+                    legacyStopError = e;
+                }
+                log(`❌ runAgent 失败: ${e.message}`);
+                dslog("run.error", `runAgent 失败: ${e.message}`, {
+                    level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
+                    error_message: e.message, error_stack: e.stack,
+                });
+                let report;
+                if (scheduled) {
+                    try {
+                        report = await reportScheduledStartFailure(config, {
+                            handle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            scheduled,
+                            errorMessage: e.message,
+                        });
+                    }
+                    catch { /* token 也不可用时只能让 server 按 runtime failure 终态化 */ }
+                }
+                reportAgentRunComplete(ws?.readyState === WebSocket.OPEN ? ws : null, {
+                    runId,
+                    agentHandle: msg.agentHandle,
+                    channelId: msg.channelId,
+                    threadId: threadId ?? null,
+                    exitCode: -1,
+                    errorMessage: e.message,
+                    ...(!scheduled && msg.wake?.origin ? {
+                        wakeOrigin: msg.wake.origin,
+                        originDecision: "missing",
+                    } : {}),
+                    ...(scheduled ? { scheduledRunId: scheduled.runId } : {}),
+                    ...(report ? { report } : {}),
+                }, dslog);
+            }
+            finally {
+                running.delete(key);
+                legacyReservation?.release();
+                finishLegacyQueue();
+                if (legacyQueueDone && legacyTaskTails.get(key) === legacyQueueDone) {
+                    legacyTaskTails.delete(key);
+                }
+                legacyRuns.delete(runId);
+                if (legacyStopError === undefined)
+                    finishLegacyRun();
+                else
+                    failLegacyRun(legacyStopError);
+                void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
+            }
+        });
+        ws.on("close", (code) => {
+            if (stopped)
+                return;
+            completionRetransmitter.pause();
+            // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
+            // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。
+            if (code === 4001) {
+                backoff = maxBackoff;
+                log(`🛑 控制面以鉴权失败关闭连接 (code 4001):机器凭证无效或已吊销。`);
+                log(`   请在 NowWork 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
+            }
+            log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
+            // 此刻 server 大概率不可达 → 这条会落 spool,重连 drainSpool 时补传;
+            // ts 是现在(断开时刻),排查「daemon 为什么断」以它对齐 server 侧 machine_disconnected。
+            dslog("daemon.ws_close", `控制面断开 (code ${code})`, {
+                level: "WARN", close_code: code, backoff_ms: backoff,
+                online_ms: connectedAt ? Date.now() - connectedAt : null,
+                running_tasks: [...running].join(","),
+            });
+            void flushSlog();
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
+                connect();
+            }, backoff);
+            backoff = Math.min(backoff * 2, maxBackoff);
+        });
+        ws.on("error", () => {
+            if (!stopped)
+                ws?.close();
+        });
+    }
+    const ready = (async () => {
+        await reconcileExecutionJournal(executionJournal, {
+            agentsRoot: config.agentsRoot,
+            serverUrl: config.serverUrl,
+            ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
+            log: dslog,
+            flush: flushSlog,
+            writeStderr: (line) => process.stderr.write(line),
+        });
+        connect();
+    })();
+    const stop = () => {
+        if (stopPromise !== null)
+            return stopPromise;
+        stopPromise = (async () => {
+            stopped = true;
+            completionRetransmitter.stop();
+            const deadline = createShutdownDeadline(shutdownTimeoutMs);
+            if (reconnectTimer !== null) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            const webSocketClosed = closeWebSocketWithinDeadline(ws, deadline.signal);
+            const pending = [
+                webSocketClosed,
+                executionFrameQueue,
+                ...executionRuns.values(),
+                ...[...legacyRuns.values()].map((run) => run.done),
+                ...(testShutdown.barrier === null ? [] : [testShutdown.barrier]),
+            ];
+            try {
+                for (const executionId of executionRuns.keys())
+                    requestCancellation(executionId);
+                for (const run of legacyRuns.values())
+                    run.controller.request();
+                await deadline.waitFor(Promise.all(pending));
+                await executionJournal.close({ signal: deadline.signal });
+            }
+            finally {
+                deadline.dispose();
+            }
+        })();
+        return stopPromise;
+    };
+    return {
+        ready,
+        stop,
+        shutdownSnapshot: () => ({
+            activeExecutionCount: executionRuns.size,
+            activeLegacyCount: legacyRuns.size,
+            deadlineMs: shutdownTimeoutMs,
+        }),
+    };
+}