@nowcrew/daemon 0.5.15 → 0.5.16

package/dist/bound-im-decision.js

@@ -0,0 +1,22 @@
+import { readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+export function boundImDecisionFilePath(runDir) {
+    return join(runDir, ".bound-im-decision.json");
+}
+export async function resetBoundImDecisionFile(path) {
+    await unlink(path).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+export async function readBoundImDecisionFile(path) {
+    try {
+        const parsed = JSON.parse(await readFile(path, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        return parsed.decision === "notify" ? { decision: "notify" } : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/execution-protocol.js

@@ -55,6 +55,7 @@ export const LegacyAgentStartSchema = z.object({
         runId: z.string().min(1),
         title: z.string().optional(),
         outputPolicy: z.unknown().optional(),
+        externalNotificationPolicy: z.unknown().optional(),
     }).passthrough().optional(),
     silent: z.boolean().optional(),
 }).passthrough();
@@ -119,6 +120,7 @@ export const ExecutionStartSchema = z.object({
         captureFinal: z.boolean(),
         streamActivity: z.boolean(),
         streamConsole: z.boolean(),
+        allowBoundImDecision: z.boolean().optional(),
     }).strict(),
 }).strict();
 export const ExecutionCancelSchema = z.object({
@@ -203,6 +205,7 @@ const RawExecutionCompletedSchema = z.object({
     model: z.string().optional(),
     resumed: z.boolean(),
     finalText: z.string().optional(),
+    boundImDecision: z.enum(["notify", "silent"]).optional(),
     usage: ExecutionUsageSchema.optional(),
     startedAt: TimestampSchema,
     finishedAt: TimestampSchema,

package/dist/execution-runner.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DaemonToServerExecutionFrameSchema, ExecutionCompletedSchema, ExecutionRejectedSchema, ExecutionStartSchema, } from "./execution-protocol.js";
 import { JournalConflictError } from "./execution-journal.js";
@@ -10,6 +11,7 @@ import { buildClaudeArgs, CLAUDE_EFFORT_LEVELS } from "./runtimes/claude.js";
 import { buildCodexArgs, CODEX_EFFORT_LEVELS } from "./runtimes/codex.js";
 import { KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
 import { executionBackendCapability } from "./execution-backend.js";
+import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 const ACTIVITY_KIND = {
     init: "working",
     text: "thinking",
@@ -411,6 +413,8 @@ export async function runExecution(config, input, dependencies) {
     const mint = dependencies.mintAgentToken ?? mintAgentToken;
     const execute = dependencies.executeLocal ?? executeLocal;
     const startSupervisor = dependencies.startSupervisor ?? startDormantSupervisor;
+    const readBoundImDecision = dependencies.readBoundImDecision ?? readBoundImDecisionFile;
+    const resetBoundImDecision = dependencies.resetBoundImDecision ?? resetBoundImDecisionFile;
     const telemetry = new TelemetryQueue(dependencies.report, bestEffortTimeoutMs, positiveTelemetryLimit(dependencies.telemetryMaxPendingFrames, DEFAULT_TELEMETRY_MAX_PENDING_FRAMES), Math.max(config.executionLimits.maxEventBytes, positiveTelemetryLimit(dependencies.telemetryMaxPendingBytes, DEFAULT_TELEMETRY_MAX_PENDING_BYTES)));
     const supervisorState = { active: null, abortOnce: null };
     let launchClosed = false;
@@ -423,6 +427,9 @@ export async function runExecution(config, input, dependencies) {
     let timeout;
     let timedOut = false;
     let completion;
+    let boundImDecision = spec.reporting.allowBoundImDecision
+        ? "silent"
+        : undefined;
     let rejectCancellationFailure;
     const cancellationFailure = new Promise((_resolve, reject) => {
         rejectCancellationFailure = reject;
@@ -431,7 +438,7 @@ export async function runExecution(config, input, dependencies) {
         if (dependencies.slot !== undefined) {
             await cancellable(dependencies.slot.ready, dependencies.cancellation);
         }
-        const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId }), dependencies.cancellation);
+        const credential = await cancellable(mint(config.serverUrl, config.machineToken, spec.agent.handle, undefined, { executionId: spec.executionId, agentRunId: spec.executionId }), dependencies.cancellation);
         const providerConfig = launchProviderConfig(credential.config);
         let activitySequence = 0;
         let consoleSequence = 0;
@@ -554,6 +561,11 @@ export async function runExecution(config, input, dependencies) {
                 cliPath: config.cliPath,
                 providerConfig,
                 ...(providerConfig.description ? { description: providerConfig.description } : {}),
+                ...(spec.reporting.allowBoundImDecision ? {
+                    systemEnv: {
+                        CREW_BOUND_IM_DECISION_FILE: `.bound-im-decision-${spec.executionId}.json`,
+                    },
+                } : {}),
             },
             session: {
                 enabled: config.resume,
@@ -570,6 +582,12 @@ export async function runExecution(config, input, dependencies) {
         if (timeout !== undefined)
             clearTimeout(timeout);
         const finishedAt = now().toISOString();
+        if (spec.reporting.allowBoundImDecision) {
+            const path = join(result.workspaceRunDir, `.bound-im-decision-${spec.executionId}.json`);
+            const selected = await readBoundImDecision(path);
+            await resetBoundImDecision(path);
+            boundImDecision = selected?.decision ?? "silent";
+        }
         completion = ExecutionCompletedSchema.parse(timedOut ? {
             type: "execution:completed",
             protocolVersion: 1,
@@ -580,6 +598,7 @@ export async function runExecution(config, input, dependencies) {
             runtime: result.runtime,
             ...(result.model === null ? {} : { model: result.model }),
             resumed: result.resumed,
+            ...(boundImDecision ? { boundImDecision } : {}),
             startedAt,
             finishedAt,
         } : {
@@ -596,6 +615,7 @@ export async function runExecution(config, input, dependencies) {
             runtime: result.runtime,
             ...(result.model === null ? {} : { model: result.model }),
             resumed: result.resumed,
+            ...(boundImDecision ? { boundImDecision } : {}),
             ...(!spec.reporting.captureFinal || result.finalText === null
                 ? {}
                 : { finalText: result.finalText }),

package/dist/origin-decision.js

@@ -27,7 +27,7 @@ export async function readOriginDecisionFile(path) {
     }
 }
 export function shouldRetryOriginDecision(wakeOrigin, decision, attempt) {
-    return wakeOrigin === "wecom" && decision === null && attempt === 0;
+    return wakeOrigin === "wecom" && decision?.decision !== "reply" && attempt === 0;
 }
 export async function runWithOriginDecisionGuard(wakeOrigin, runAttempt) {
     const first = await runAttempt(0);

package/dist/prompt.js

@@ -91,14 +91,15 @@ export function buildSystemPrompt(ctx) {
 ## 定时任务创建与管理
 平台不会用关键词预先区分创建或管理意图,由你根据完整来信和上下文判断用户是要创建定时任务,还是查看、修改、暂停、恢复、取消或立即执行已有任务。
 1. 定时任务创建与管理无需 \`crew task claim\`;不要仅为创建或管理定时任务而创建 task。
-2. 创建时使用 \`crew schedule create --agent ${ctx.handle} --channel ${ctx.channelId} --prompt '<text>' (--cron '<expr>' | --at '<ISO>')\`,不得编造或替换当前 agent 身份与频道。
+2. 创建时使用 \`crew schedule create --agent ${ctx.handle} --channel ${ctx.channelId} --prompt '<text>' (--cron '<expr>' | --at '<ISO>') [--external-notification <disabled|agent-decides>]\`,不得编造或替换当前 agent 身份与频道。
 3. \`crew schedule create\` 和 \`crew schedule update\` 都必须遵守这条规则:\`prompt\`、\`title\`、\`cron\`、\`at\`、\`timezone\` 的值都必须分别作为单个 shell 参数传入,使用单引号 shell 引用;值内若含单引号,必须按标准方式关闭单引号、写入转义后的单引号、再重新开启单引号。不得在创建或更新持久化前展开或执行用户内容中的 \`$\`、反引号或 \`$()\`。
 4. 创建时默认使用 \`--output-policy always-report\`。创建时只有用户明确要求静默、不发送正常结果或仅在异常时汇报时,才使用 \`--output-policy on-exception\`。
 5. 更新时若用户未明确要求改变汇报行为,必须省略 \`--output-policy\` 并保留已有策略。只有用户明确要求改变汇报行为时,才按同样规则映射输出策略:正常汇报用 \`always-report\`,静默或仅异常汇报用 \`on-exception\`。创建或更新汇报行为时,把用户原始的汇报条件保留在 \`--prompt\` 中,不要改写或省略。汇报要求确实有歧义时,先向用户确认。
-6. 执行时间、时区或执行指令信息不足时,先向用户确认,不得猜测。
-7. 查询现状或执行 create/update/pause/resume/cancel/run-now 任何操作前,先运行 \`crew schedule list --channel ${ctx.channelId} --agent ${ctx.handle} --json\` 查询本频道绑定到你自己的候选;仅查看时也使用这条 JSON 查询,以获取完整的 cron/at/timezone/prompt/output policy。
-8. 只有一个明确匹配时,才运行 \`crew schedule update <jobId> ...\` 或对应 pause/resume/cancel/run-now 命令。有多个合理候选时,列出候选并先让用户选择;用户选定前不得修改任何任务。
-9. 修改请求不能用 \`crew schedule create\` 代替。完成后回复 job ID、最终 schedule、timezone 和 output policy;更新还要列出变更字段的前后值。`;
+6. 绑定会话通知创建时默认使用 \`disabled\`。只有用户明确要求将合适结果通知绑定会话时,才使用 \`--external-notification agent-decides\`;用户未明确要求修改该授权时,更新时必须省略 \`--external-notification\` 并保留已有策略。
+7. 执行时间、时区或执行指令信息不足时,先向用户确认,不得猜测。
+8. 查询现状或执行 create/update/pause/resume/cancel/run-now 任何操作前,先运行 \`crew schedule list --channel ${ctx.channelId} --agent ${ctx.handle} --json\` 查询本频道绑定到你自己的候选;仅查看时也使用这条 JSON 查询,以获取完整的 cron/at/timezone/prompt/output policy/external notification policy。
+9. 只有一个明确匹配时,才运行 \`crew schedule update <jobId> ...\` 或对应 pause/resume/cancel/run-now 命令。有多个合理候选时,列出候选并先让用户选择;用户选定前不得修改任何任务。
+10. 修改请求不能用 \`crew schedule create\` 代替。完成后回复 job ID、最终 schedule、timezone、output policy 和 external notification policy;更新还要列出变更字段的前后值。`;
     const voiceRule = alwaysReport
         ? "- **本轮报告只写在 runtime 最终回复中**:不要调用 `crew message send`;daemon 会把最终回复投递到频道。"
         : "- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**";
@@ -115,7 +116,7 @@ export function buildSystemPrompt(ctx) {
 8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
 9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
 10. **\`crew task assign <taskId> --to <handle>\`** —— 把任务指派/交接给另一个 agent(用于交接,见下)。
-11. **\`crew schedule create --agent <handle> --channel <id> --prompt <text> [--title <t>] (--cron <expr> | --at <ISO>) [--timezone <iana>] [--output-policy <always-report|on-exception>]\`** —— 创建定时任务。
+11. **\`crew schedule create --agent <handle> --channel <id> --prompt <text> [--title <t>] (--cron <expr> | --at <ISO>) [--timezone <iana>] [--output-policy <always-report|on-exception>] [--external-notification <disabled|agent-decides>]\`** —— 创建定时任务。
 12. **\`crew schedule list --channel <id> --agent <handle> [--json]\`** —— 查询本频道指定 agent 的定时任务,\`--json\` 返回完整字段。
 13. **\`crew schedule update <jobId> ...\`** —— 修改定时任务标题、指令、时间或输出策略。
 14. **\`crew schedule pause|resume|cancel|run-now <jobId>\`** —— 控制定时任务。`;
@@ -139,10 +140,13 @@ ${taskAndScheduleCommands}`;
         : `
 - **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。`;
     const externalReplyRule = scheduled
-        ? ""
+        ? ctx.scheduledExternalNotificationPolicy === "agent_decides"
+            ? `
+- **绑定会话通知由你选择**:只有本轮完整结果确实值得打扰绑定会话时,运行 \`crew message notify-bound-im --channel ${ctx.channelId}\` 一次,然后仍只返回一个完整最终报告。该命令只记录本轮决策,不会自行发消息,也不能指定收件人。`
+            : ""
         : ctx.wakeOrigin === "wecom"
             ? `
-- **本轮来自企微，结束本轮前必须明确选择外部回复决策**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。完整结果确实要回复企微时，用 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）；判断无需回复企微时，用 \`crew message skip-origin --reason "简短原因"\`。两者必须选择一个；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定。`
+- **本轮来自企微，结束本轮前必须给出一条完整回复**:确认、过程进展和内部协作仍用普通 \`crew message send\`，只写入 NowWork。最终只用一次 \`crew message send --reply-origin\`（同时带当前 channel/thread/content 参数）发送有实质内容的完整结果；不要把 \`--send-draft\` 当成草稿 ID 或外部回复开关。Server 仍会校验 thread 来源和机器人绑定，并在本轮未形成可交付内容时发送统一兜底回复。`
             : `
 - **外部来源回复由你决定**:普通 \`crew message send\` 只写入 NowWork。只有当前 thread 明确来自企微等外部 IM、且这条消息确实要回复外部发言人时,才给该次发送加 \`--reply-origin\`;Server 会按当前 thread 的已验证来源路由,你不能指定任意机器人或会话。确认、过程进展、内部协作消息不要使用该参数。若判断无需回外部,只发普通内部消息或保持沉默。`;
     const interactiveTaskRules = scheduled ? "" : `
@@ -255,11 +259,14 @@ ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memor
 /** 静默定时任务的唤醒提示词:不注入协作礼仪/线程提示;默认零输出(设计文档 §5.4)。
  *  汇报用 --send-draft:绕过 freshness hold(-p 单发不跑 crew read,游标落后,
  *  普通 send 会被 202 扣成 draft——监控告警绝不能被静默扣留)。 */
-export function buildScheduledPrompt(channelId, jobPrompt, outputPolicy = "silent_unless_report") {
-    if (outputPolicy === "always_report") {
+export function buildScheduledPrompt(channelId, jobPrompt, outputPolicy = "silent_unless_report", externalNotificationPolicy = "disabled") {
+    if (outputPolicy === "always_report" || externalNotificationPolicy === "agent_decides") {
         return [
             "You are executing a scheduled job. No one is waiting for an acknowledgement.",
             `Scheduled instruction: ${jobPrompt}`,
+            ...(externalNotificationPolicy === "agent_decides" ? [
+                `If and only if this complete result warrants notifying the bound conversation, run \`crew message notify-bound-im --channel ${channelId}\` once. The command records a local decision and does not send a second message.`,
+            ] : []),
             "Return exactly one self-contained final report as your runtime final response.",
             "Do not call crew message send; the daemon delivers the final response.",
             "Do not send acknowledgements or progress messages.",
@@ -289,8 +296,8 @@ export function buildOriginDecisionRetryPrompt(channelId, threadId) {
     const thread = threadId ? ` --thread ${threadId}` : "";
     return [
         "本轮尚未完成企微回复决策。不要重复执行已经完成的工作，只完成下面这个决策后结束：",
-        `- 需要回复企微：用 crew message send --channel ${channelId}${thread} --reply-origin --content "完整最终回复"。`,
-        `- 不需要回复企微：用 crew message skip-origin --channel ${channelId} --reason "简短原因"。`,
+        `- 必须回复企微：用 crew message send --channel ${channelId}${thread} --reply-origin --content "完整最终回复"。`,
+        "- 只发送一条有实质内容的完整回复，不要拆成确认、进展和结论多条外部消息。",
         "普通内部消息不算外部回复决策；--send-draft 也不是外部回复开关。",
     ].join("\n");
 }

package/dist/runner.js

@@ -7,6 +7,7 @@ import { deliverScheduledReport, } from "./scheduled-report.js";
 import { executeLocal } from "./local-executor.js";
 import { ReasoningSchema } from "./execution-protocol.js";
 import { readOriginDecisionFile, resetOriginDecisionFile } from "./origin-decision.js";
+import { readBoundImDecisionFile, resetBoundImDecisionFile } from "./bound-im-decision.js";
 export { awaitExit, exitActivity, sanitizeEnvVars } from "./local-executor.js";
 const ICON = {
     init: "🟢", text: "💬", reading: "📖", sending: "📨", checking: "🔎",
@@ -31,6 +32,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
     const originDecisionFileName = input.wakeOrigin === "wecom"
         ? `.origin-decision-${executionId}.json`
         : null;
+    const boundImDecisionFileName = input.scheduled?.externalNotificationPolicy === "agent_decides"
+        ? `.bound-im-decision-${executionId}.json`
+        : null;
     const local = await executeLocal({
         executionId,
         handle: input.handle,
@@ -45,6 +49,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             productName: config.productName,
             platform: process.platform,
             ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
+            ...(input.scheduled?.externalNotificationPolicy
+                ? { scheduledExternalNotificationPolicy: input.scheduled.externalNotificationPolicy }
+                : {}),
             ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
             memory: capMemoryForInject(workspace.memory),
             ...(resuming ? {} : { workLog: capWorkLogForInject(workspace.workLog) }),
@@ -82,6 +89,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
                     CREW_WAKE_ORIGIN: "wecom",
                     CREW_ORIGIN_DECISION_FILE: originDecisionFileName,
                 } : {}),
+                ...(boundImDecisionFileName ? {
+                    CREW_BOUND_IM_DECISION_FILE: boundImDecisionFileName,
+                } : {}),
             },
         },
         session: {
@@ -117,9 +127,20 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         process.stdout.write(`📊 tokens: in=${usage.inputTokens} out=${usage.outputTokens} cache_read=${usage.cacheReadTokens} cache_create=${usage.cacheCreationTokens}`
             + `${usage.costUsd != null ? ` cost=$${usage.costUsd.toFixed(4)}` : ""} ${local.resumed ? "(resumed)" : "(fresh)"}\n`);
     }
+    const boundImDecisionPath = boundImDecisionFileName
+        ? join(local.workspaceRunDir, boundImDecisionFileName)
+        : null;
+    const selectedBoundImDecision = boundImDecisionPath
+        ? await readBoundImDecisionFile(boundImDecisionPath)
+        : null;
+    if (boundImDecisionPath)
+        await resetBoundImDecisionFile(boundImDecisionPath);
+    const boundImDecision = boundImDecisionPath
+        ? selectedBoundImDecision?.decision ?? "silent"
+        : undefined;
     const report = input.scheduled
         ? await deliverScheduledReport({
-            policy: input.scheduled.outputPolicy,
+            policy: boundImDecision === "notify" ? "always_report" : input.scheduled.outputPolicy,
             title: input.scheduled.title,
             exitCode: local.exitCode,
             finalText: local.finalText,
@@ -127,6 +148,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
                 content,
                 force: true,
+                ...(boundImDecision === "notify" ? { notifyBoundIm: true } : {}),
             }),
         })
         : undefined;
@@ -146,6 +168,7 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
         errorMessage: local.errorMessage,
         ...(local.usage ? { usage: local.usage } : {}),
         ...(report ? { report } : {}),
+        ...(boundImDecision ? { boundImDecision } : {}),
         ...(input.wakeOrigin === "wecom" ? {
             originDecision: originDecision?.decision ?? "missing",
             ...(originDecision?.decision === "silent" && originDecision.reason

package/dist/scheduled-report.js

@@ -1,12 +1,16 @@
 export function normalizeScheduledPolicy(value) {
     return value === "always_report" ? "always_report" : "silent_unless_report";
 }
+export function normalizeExternalNotificationPolicy(value) {
+    return value === "agent_decides" ? "agent_decides" : "disabled";
+}
 export function normalizeScheduledContext(input) {
     return {
         jobId: input.jobId,
         runId: input.runId,
         title: input.title?.trim() || "Scheduled job",
         outputPolicy: normalizeScheduledPolicy(input.outputPolicy),
+        externalNotificationPolicy: normalizeExternalNotificationPolicy(input.externalNotificationPolicy),
     };
 }
 export async function deliverScheduledReport(input) {

package/dist/scheduled-run-report.js

@@ -27,6 +27,7 @@ export function reportAgentRunComplete(socket, input, log) {
         exitCode: input.exitCode,
         ...(input.wakeOrigin ? { wakeOrigin: input.wakeOrigin } : {}),
         ...(input.originDecision ? { originDecision: input.originDecision } : {}),
+        ...(input.contextUpToSeq !== undefined ? { contextUpToSeq: input.contextUpToSeq } : {}),
         ...(input.runtime ? { runtime: input.runtime } : {}),
         ...(input.model !== undefined ? { model: input.model } : {}),
         ...(input.resumed !== undefined ? { resumed: input.resumed } : {}),

package/dist/serve.js

@@ -515,6 +515,9 @@ export function serve(config, opts = {}) {
                     ...(msg.scheduledRun.outputPolicy !== undefined
                         ? { outputPolicy: msg.scheduledRun.outputPolicy }
                         : {}),
+                    ...(msg.scheduledRun.externalNotificationPolicy !== undefined
+                        ? { externalNotificationPolicy: msg.scheduledRun.externalNotificationPolicy }
+                        : {}),
                 })
                 : null;
             const threadId = msg.wake?.threadId;
@@ -619,7 +622,7 @@ export function serve(config, opts = {}) {
                     ? `crew thread read`
                     : `crew message read --channel ${msg.channelId}`;
                 const wakeText = scheduled
-                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy)
+                    ? 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);
@@ -639,7 +642,11 @@ export function serve(config, opts = {}) {
                         taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
                         runId, // 贯穿 SLS 日志的单轮关联键
                         ...(scheduled ? {
-                            scheduled: { title: scheduled.title, outputPolicy: scheduled.outputPolicy },
+                            scheduled: {
+                                title: scheduled.title,
+                                outputPolicy: scheduled.outputPolicy,
+                                externalNotificationPolicy: scheduled.externalNotificationPolicy,
+                            },
                         } : {}),
                         ...(wakeOrigin ? { wakeOrigin, originDecisionAttempt: attempt } : {}),
                         // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
@@ -685,6 +692,7 @@ export function serve(config, opts = {}) {
                     ...(wakeOrigin ? {
                         wakeOrigin,
                         originDecision: result.originDecision ?? "missing",
+                        ...(msg.wake?.seq !== undefined ? { contextUpToSeq: msg.wake.seq } : {}),
                     } : {}),
                     ...(scheduled ? { scheduledRunId: scheduled.runId } : {}),
                     ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.15",
+  "version": "0.5.16",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -21,7 +21,7 @@
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.7"
+    "@nowcrew/cli": "^0.4.8"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",