@nowcrew/daemon 0.5.11 → 0.5.13

package/dist/scheduled-run-report.js

@@ -1,6 +1,6 @@
 function fields(input) {
     return {
-        scheduled_run_id: input.scheduledRunId,
+        ...(input.scheduledRunId ? { scheduled_run_id: input.scheduledRunId } : {}),
         run_id: input.runId,
         agent_handle: input.agentHandle,
         channel_id: input.channelId,
@@ -9,19 +9,24 @@ function fields(input) {
         ...(input.model ? { model: input.model } : {}),
     };
 }
-export function reportScheduledRunComplete(socket, input, log) {
+export function reportAgentRunComplete(socket, input, log) {
+    const eventPrefix = input.scheduledRunId ? "scheduled_run" : "run";
     if (!socket) {
-        log("scheduled_run.complete_send_failed", "定时任务完成回报未发送:控制面连接不可用", {
+        log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报未发送:控制面连接不可用", {
             level: "WARN", ...fields(input), error_message: "control socket unavailable",
         });
         return;
     }
     const payload = JSON.stringify({
         type: "agent:run-complete",
+        runId: input.runId,
         agentHandle: input.agentHandle,
         channelId: input.channelId,
-        scheduledRunId: input.scheduledRunId,
+        ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
+        ...(input.scheduledRunId ? { scheduledRunId: input.scheduledRunId } : {}),
         exitCode: input.exitCode,
+        ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
+        ...(input.originDecision ? { originDecision: input.originDecision } : {}),
         ...(input.runtime ? { runtime: input.runtime } : {}),
         ...(input.model !== undefined ? { model: input.model } : {}),
         ...(input.resumed !== undefined ? { resumed: input.resumed } : {}),
@@ -32,17 +37,20 @@ export function reportScheduledRunComplete(socket, input, log) {
     try {
         socket.send(payload, (error) => {
             if (error) {
-                log("scheduled_run.complete_send_failed", "定时任务完成回报发送失败", {
+                log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报发送失败", {
                     level: "WARN", ...fields(input), error_message: error.message,
                 });
                 return;
             }
-            log("scheduled_run.complete_sent", "定时任务完成回报已发送", fields(input));
+            log(`${eventPrefix}.complete_sent`, "Agent 完成回报已发送", fields(input));
         });
     }
     catch (error) {
-        log("scheduled_run.complete_send_failed", "定时任务完成回报发送失败", {
+        log(`${eventPrefix}.complete_send_failed`, "Agent 完成回报发送失败", {
             level: "WARN", ...fields(input), error_message: error.message,
         });
     }
 }
+export function reportScheduledRunComplete(socket, input, log) {
+    reportAgentRunComplete(socket, input, log);
+}

package/dist/serve.js

@@ -6,24 +6,32 @@ import { WebSocket } from "ws";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
-import { reportScheduledStartFailure, runAgent } from "./runner.js";
-import { buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, DAEMON_CAPABILITIES } from "./machine-info.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 { reportScheduledRunComplete } from "./scheduled-run-report.js";
+import { reportAgentRunComplete } from "./scheduled-run-report.js";
+import { runWithOriginDecisionGuard } from "./origin-decision.js";
+import { createExecutionJournal } from "./execution-journal.js";
+import { ExecutionRejectedSchema, ExecutionSnapshotSchema, LegacyAgentStartSchema, ServerToDaemonExecutionFrameSchema, } from "./execution-protocol.js";
+import { hashExecutionSpec, runExecution, } from "./execution-runner.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) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform) {
     const query = new URLSearchParams({ key: machineToken });
+    if (runtimePlatform !== "win32") {
+        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()}`;
@@ -34,34 +42,187 @@ export function serve(config, opts = {}) {
     let ws = null;
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    const executionJournal = opts.execution?.journal ?? createExecutionJournal(config.agentsRoot);
+    const executeProtocol = opts.execution?.runExecution ?? runExecution;
+    let detectedRuntimes = [];
+    let runtimeFacts = null;
+    const executionReady = executionJournal.reconcileAfterRestart().then(() => true, (error) => {
+        dslog("execution.recovery_failed", "execution journal 恢复失败", {
+            level: "ERROR", error_message: error.message,
+        });
+        return false;
+    });
+    const sharedActive = new Map();
+    const sharedQueues = new Map();
+    const knownExecutionHashes = new Map();
+    const executionReservations = new Map();
+    const executionRuns = new Map();
+    let executionFrameQueue = Promise.resolve();
+    const cancellations = new Map();
+    const safeExecutionSend = (frame) => {
+        try {
+            if (ws?.readyState === WebSocket.OPEN)
+                ws.send(JSON.stringify(frame));
+        }
+        catch { /* reconnect/sync replays durable lifecycle */ }
+    };
+    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) {
+            safeExecutionSend(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 startStop = (state) => {
+            if (!state.requested || state.cancel === null)
+                return Promise.resolve();
+            state.stopPromise ??= Promise.resolve().then(state.cancel);
+            return state.stopPromise;
+        };
+        const existing = cancellations.get(executionId);
+        if (existing !== undefined) {
+            return {
+                isRequested: () => existing.requested,
+                requested: existing.promise,
+                register: (cancel) => {
+                    existing.cancel = cancel;
+                    void startStop(existing).catch(() => { });
+                },
+                waitForStop: () => startStop(existing),
+            };
+        }
+        let resolve;
+        const promise = new Promise((done) => { resolve = done; });
+        const state = {
+            requested: false, resolve, promise,
+            cancel: null,
+            stopPromise: null,
+        };
+        cancellations.set(executionId, state);
+        return {
+            isRequested: () => state.requested,
+            requested: promise,
+            register: (cancel) => {
+                state.cancel = cancel;
+                void startStop(state).catch(() => { });
+            },
+            waitForStop: () => startStop(state),
+        };
+    };
+    const requestCancellation = (executionId) => {
+        cancellationFor(executionId);
+        const state = cancellations.get(executionId);
+        if (state.requested)
+            return;
+        state.requested = true;
+        state.resolve();
+        const reservation = executionReservations.get(executionId);
+        if (reservation?.isQueued()) {
+            reservation.release();
+        }
+        if (state.cancel !== null && state.stopPromise === null) {
+            state.stopPromise = Promise.resolve().then(state.cancel);
+            void state.stopPromise.catch(() => { });
+        }
+    };
+    const promoteNext = (handle) => {
+        const queue = sharedQueues.get(handle) ?? [];
+        while ((sharedActive.get(handle) ?? 0) < config.executionLimits.maxParallelPerAgent && queue.length > 0) {
+            const next = queue.shift();
+            if (next.released)
+                continue;
+            next.promoted = true;
+            sharedActive.set(handle, (sharedActive.get(handle) ?? 0) + 1);
+            next.resolve();
+        }
+        if (queue.length === 0)
+            sharedQueues.delete(handle);
+    };
+    const reserveSharedSlot = (handle, kind) => {
+        const active = sharedActive.get(handle) ?? 0;
+        const queued = sharedQueues.get(handle)?.length ?? 0;
+        const facts = { activeForAgent: active, queuedForAgent: queued };
+        if (kind === "execution" && active >= config.executionLimits.maxParallelPerAgent
+            && queued >= config.executionLimits.maxQueuedPerAgent) {
+            return { facts, ready: Promise.resolve(), isQueued: () => false, release: () => { } };
+        }
+        let resolve;
+        const ready = new Promise((done) => { resolve = done; });
+        const entry = { kind, released: false, promoted: active < config.executionLimits.maxParallelPerAgent, resolve };
+        if (entry.promoted) {
+            sharedActive.set(handle, active + 1);
+            resolve();
+        }
+        else {
+            const queue = sharedQueues.get(handle) ?? [];
+            queue.push(entry);
+            sharedQueues.set(handle, queue);
+        }
+        return {
+            facts,
+            state: entry.promoted ? "ready" : "queued",
+            ready,
+            isQueued: () => !entry.promoted && !entry.released,
+            release: () => {
+                if (entry.released)
+                    return;
+                entry.released = true;
+                if (entry.promoted) {
+                    sharedActive.set(handle, Math.max(0, (sharedActive.get(handle) ?? 1) - 1));
+                }
+                else {
+                    const queue = sharedQueues.get(handle);
+                    const index = queue?.indexOf(entry) ?? -1;
+                    if (queue !== undefined && index >= 0)
+                        queue.splice(index, 1);
+                    if (queue?.length === 0)
+                        sharedQueues.delete(handle);
+                }
+                promoteNext(handle);
+            },
+        };
+    };
     let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
     initSlog(config.serverUrl, config.machineToken);
     dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
     // - running:正在跑的「agent:任务」去重键(同一任务重复唤醒才跳过)。
-    // - agentSlots:每 agent 当前并行数;超过 MAX_PARALLEL 的进 FIFO 队列(不丢)。
-    const MAX_PARALLEL = Number(process.env.CREW_MAX_PARALLEL) || 4;
+    // - agentSlots:每 agent 当前并行数;超过配置上限的进 FIFO 队列(不丢)。
     const running = new Set();
-    const agentSlots = new Map();
-    const waitQueue = new Map();
     const acquireSlot = async (handle) => {
-        const n = agentSlots.get(handle) ?? 0;
-        if (n < MAX_PARALLEL) {
-            agentSlots.set(handle, n + 1);
-            return;
-        }
-        await new Promise((resolve) => {
-            const q = waitQueue.get(handle) ?? [];
-            q.push(resolve);
-            waitQueue.set(handle, q);
-        });
-        agentSlots.set(handle, (agentSlots.get(handle) ?? 0) + 1);
+        await reserveSharedSlot(handle, "legacy").ready;
     };
     const releaseSlot = (handle) => {
-        agentSlots.set(handle, Math.max(0, (agentSlots.get(handle) ?? 1) - 1));
-        const q = waitQueue.get(handle);
-        if (q && q.length)
-            (q.shift())();
+        sharedActive.set(handle, Math.max(0, (sharedActive.get(handle) ?? 1) - 1));
+        promoteNext(handle);
     };
     const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
     function connect() {
@@ -76,8 +237,16 @@ export function serve(config, opts = {}) {
             // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
             void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
-            void collectMachineHello(config.agentsRoot)
+            const helloPromise = collectMachineHello(config.agentsRoot, config.executionLimits);
+            runtimeFacts = helloPromise.then((hello) => hello.runtimes, (error) => {
+                dslog("execution.runtime_detection_failed", "runtime 探测失败", {
+                    level: "ERROR", error_message: error.message,
+                });
+                return [];
+            });
+            void helloPromise
                 .then((hello) => {
+                detectedRuntimes = hello.runtimes;
                 try {
                     ws?.send(JSON.stringify(hello));
                     log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · runtimes=[${hello.runtimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
@@ -86,15 +255,153 @@ export function serve(config, opts = {}) {
             })
                 .catch(() => { });
             opts.onOpen?.(ws);
+            void executionReady.then((ready) => ready ? sendSnapshot(`reconnect-${randomUUID()}`) : undefined);
         });
         ws.on("message", async (data) => {
-            let msg;
+            let decoded;
             try {
-                msg = JSON.parse(data.toString());
+                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 () => {
+                    const recovered = await executionReady;
+                    if (frame.type === "execution:completion-ack") {
+                        await executionJournal.acknowledgeCompletion(frame.executionId).catch(() => { });
+                        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;
+                    if (!recovered) {
+                        safeExecutionSend(ExecutionRejectedSchema.parse({
+                            type: "execution:rejected", protocolVersion: 1, executionId: spec.executionId,
+                            reason: "resource_limit", message: "Local execution journal recovery failed",
+                            at: new Date().toISOString(),
+                        }));
+                        return;
+                    }
+                    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 (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 = reserveSharedSlot(spec.agent.handle, "execution");
+                    executionReservations.set(spec.executionId, reservation);
+                    const cancellation = cancellationFor(spec.executionId);
+                    let availableRuntimes;
+                    try {
+                        availableRuntimes = opts.execution?.availableRuntimes?.()
+                            ?? await (runtimeFacts ?? Promise.resolve(detectedRuntimes));
+                    }
+                    catch (error) {
+                        reservation.release();
+                        cancellations.delete(spec.executionId);
+                        executionReservations.delete(spec.executionId);
+                        knownExecutionHashes.delete(spec.executionId);
+                        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;
+                    }
+                    const execution = executeProtocol(config, spec, {
+                        ...opts.execution?.dependencies,
+                        journal: executionJournal,
+                        facts: {
+                            availableRuntimes,
+                            ...reservation.facts,
+                        },
+                        report: safeExecutionSend,
+                        ...(reservation.state === undefined ? {} : {
+                            slot: { state: reservation.state, ready: reservation.ready },
+                        }),
+                        cancellation,
+                    }).finally(() => {
+                        reservation.release();
+                        cancellations.delete(spec.executionId);
+                        executionReservations.delete(spec.executionId);
+                        executionRuns.delete(spec.executionId);
+                        knownExecutionHashes.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)
+                return;
+            const msg = (legacy?.success ? legacy.data : decoded);
             // 控制面鉴权拒绝:server 端 resolveToken 未命中有效的 machine 凭证(失效/被吊销/
             // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
             // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
@@ -164,7 +471,14 @@ export function serve(config, opts = {}) {
             // 任务键:scheduled run 用 runId(每次运行独立 cwd/work-log;overlap 由 server 端 skip_if_running 管,
             // daemon 的 running 去重只兜底"同一 run 重复投递");普通唤醒仍是 线程锚点 ?? 频道。
             const scheduled = msg.reason === "scheduled_job" && msg.scheduledRun
-                ? normalizeScheduledContext(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 }
+                        : {}),
+                })
                 : null;
             const threadId = msg.wake?.threadId;
             const taskKey = scheduled ? scheduled.runId : (threadId ?? msg.channelId);
@@ -177,6 +491,7 @@ export function serve(config, opts = {}) {
             };
             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 (running.has(key)) {
@@ -185,7 +500,7 @@ export function serve(config, opts = {}) {
                 return;
             }
             running.add(key);
-            // 并行槽:同 agent 超过 MAX_PARALLEL 个任务时在此排队(不丢),有空位再跑。
+            // 并行槽:同 agent 超过配置上限的任务在此排队(不丢),有空位再跑。
             const slotWaitStart = Date.now();
             await acquireSlot(msg.agentHandle);
             const queueMs = Date.now() - slotWaitStart;
@@ -271,18 +586,32 @@ export function serve(config, opts = {}) {
                     : (msg.wake?.content
                         ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
                         : undefined);
-                const result = await runAgent(config, {
-                    handle: msg.agentHandle,
-                    channelId: msg.channelId,
-                    taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
-                    runId, // 贯穿 SLS 日志的单轮关联键
-                    ...(scheduled ? {
-                        scheduled: { title: scheduled.title, outputPolicy: scheduled.outputPolicy },
-                    } : {}),
-                    // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
-                    ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
-                    ...(wakeText ? { wake: wakeText } : {}),
-                }, reportActivity, reportConsole);
+                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 },
+                        } : {}),
+                        ...(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);
+                });
+                const result = mergeRunAgentResults(guarded.results);
                 // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
                 // 连同模型/runtime 一起上送控制面落库 → 支撑每 agent / 每任务(线程)的用量监控与成本核算。
                 if (result.usage) {
@@ -305,16 +634,25 @@ export function serve(config, opts = {}) {
                     }
                     catch { /* ws 非 OPEN,忽略(用量非关键路径,丢一轮不阻塞) */ }
                 }
-                // 静默定时 run:结构化完成回报(驱动 server 端 scheduled_run/job 状态落库,§5.5)
-                if (scheduled) {
-                    reportScheduledRunComplete(ws?.readyState === WebSocket.OPEN ? ws : null, {
-                        runId, scheduledRunId: scheduled.runId, agentHandle: msg.agentHandle,
-                        channelId: msg.channelId, exitCode: result.exitCode, runtime: result.runtime,
-                        model: result.model, resumed: result.resumed, usage: result.usage,
-                        ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
-                        ...(result.report ? { report: result.report } : {}),
-                    }, dslog);
-                }
+                // 所有 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",
+                    } : {}),
+                    ...(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
@@ -327,6 +665,8 @@ export function serve(config, opts = {}) {
                     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,
@@ -354,8 +694,8 @@ export function serve(config, opts = {}) {
                     level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
                     error_message: e.message, error_stack: e.stack,
                 });
+                let report;
                 if (scheduled) {
-                    let report;
                     try {
                         report = await reportScheduledStartFailure(config, {
                             handle: msg.agentHandle,
@@ -365,12 +705,21 @@ export function serve(config, opts = {}) {
                         });
                     }
                     catch { /* token 也不可用时只能让 server 按 runtime failure 终态化 */ }
-                    reportScheduledRunComplete(ws?.readyState === WebSocket.OPEN ? ws : null, {
-                        runId, scheduledRunId: scheduled.runId, agentHandle: msg.agentHandle,
-                        channelId: msg.channelId, exitCode: -1, errorMessage: e.message,
-                        ...(report ? { report } : {}),
-                    }, dslog);
                 }
+                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);
@@ -407,6 +756,12 @@ export function serve(config, opts = {}) {
         stop: () => {
             stopped = true;
             ws?.close();
+            for (const executionId of executionRuns.keys())
+                requestCancellation(executionId);
+            void Promise.race([
+                Promise.allSettled([...executionRuns.values()]).then(() => true),
+                new Promise((resolve) => setTimeout(() => resolve(false), 10_000)),
+            ]).then((settled) => settled ? executionJournal.close() : undefined);
         },
     };
 }