@nowcrew/daemon 0.5.7 → 0.5.9

package/dist/log-format.js

@@ -0,0 +1,10 @@
+export function formatDaemonLogLine(message, date = new Date(), offsetMinutes = date.getTimezoneOffset()) {
+    const local = new Date(date.getTime() - offsetMinutes * 60_000);
+    const pad = (value, width = 2) => String(value).padStart(width, "0");
+    const sign = offsetMinutes <= 0 ? "+" : "-";
+    const offset = Math.abs(offsetMinutes);
+    const timestamp = `${local.getUTCFullYear()}-${pad(local.getUTCMonth() + 1)}-${pad(local.getUTCDate())}` +
+        ` ${pad(local.getUTCHours())}:${pad(local.getUTCMinutes())}:${pad(local.getUTCSeconds())}.${pad(local.getUTCMilliseconds(), 3)}` +
+        ` ${sign}${pad(Math.floor(offset / 60))}:${pad(offset % 60)}`;
+    return `[${timestamp}] ${message}`;
+}

package/dist/machine-info.js

@@ -12,6 +12,7 @@ import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { dirname, resolve } from "node:path";
 const execFileP = promisify(execFile);
+export const DAEMON_CAPABILITIES = ["scheduled_job_v1"];
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
 const RUNTIME_BINS = [
     ["claude", "claude"],
@@ -82,6 +83,7 @@ export async function collectMachineHello(agentsRoot) {
         os: `${platform()} ${arch()}`,
         daemonVersion: daemonVersion(),
         runtimes,
+        capabilities: DAEMON_CAPABILITIES,
         agentHandles,
     };
 }

package/dist/main.js

@@ -12,6 +12,7 @@ import { cliVersion, daemonVersion } from "./machine-info.js";
 import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
 import { initSlog, flushSlog } from "./slog.js";
+import { formatDaemonLogLine } from "./log-format.js";
 async function main() {
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
@@ -55,7 +56,7 @@ async function main() {
         throw e;
     }
     if (cmd === "serve") {
-        process.stdout.write(`\n🛰️  crew-daemon v${daemonVersion()} (cli v${cliVersion()}) ${td("resident, connecting to")} ${config.serverUrl} ${td("control plane")}...\n`);
+        process.stdout.write(formatDaemonLogLine(`🛰️  crew-daemon v${daemonVersion()} (cli v${cliVersion()}) ${td("resident, connecting to")} ${config.serverUrl} ${td("control plane")}...`) + "\n");
         serve(config);
         await new Promise(() => { }); // 常驻,直到被 kill
         return;
@@ -64,7 +65,7 @@ async function main() {
         process.stderr.write(`${td("Usage:")} crew-daemon run --agent <handle> --channel <id> [--wake ...]\n`);
         process.exit(2);
     }
-    process.stdout.write(`\n🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}\n\n`);
+    process.stdout.write(formatDaemonLogLine(`🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}`) + "\n");
     initSlog(config.serverUrl, config.machineToken); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
     const result = await runAgent(config, {
         handle: values.agent,
@@ -72,7 +73,7 @@ async function main() {
         ...(values.wake ? { wake: values.wake } : {}),
         ...(values.display ? { displayName: values.display } : {}),
     });
-    process.stdout.write(`\n— ${td("agent exited")} (code ${result.exitCode}), ${td("activities")}: ${result.activities.length} —\n`);
+    process.stdout.write(formatDaemonLogLine(`— ${td("agent exited")} (code ${result.exitCode}), ${td("activities")}: ${result.activities.length} —`) + "\n");
     await flushSlog();
     process.exit(result.exitCode);
 }

package/dist/normalize.js

@@ -31,6 +31,19 @@ export function classifyCommand(command) {
         return { kind: "crew", label: "crew 命令", detail: c };
     return { kind: "tool", label: "执行命令", detail: c };
 }
+/** 从各 runtime 的最终事件提取可交付文本。调用方按事件顺序保留最后一个非空值。 */
+export function extractFinalText(event) {
+    const e = (event ?? {});
+    if (e.type === "result" && !e.is_error && e.result?.trim())
+        return e.result.trim();
+    if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
+        return e.item.text.trim();
+    }
+    if (e.role === "assistant" && !e.type && typeof e.content === "string" && e.content.trim()) {
+        return e.content.trim();
+    }
+    return null;
+}
 /** kimi 的 Bash 工具 arguments 是 JSON 字符串({"command": "..."}),容错解析出 command。 */
 function parseKimiBashCommand(args) {
     if (!args)

package/dist/prompt.js

@@ -19,17 +19,28 @@ export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
 }
 export function buildSystemPrompt(ctx) {
     const product = ctx.productName ?? "nowwork";
-    const scheduled = ctx.scheduled ?? false;
+    const scheduledPolicy = ctx.scheduledOutputPolicy
+        ?? (ctx.scheduled ? "silent_unless_report" : null);
+    const scheduled = scheduledPolicy !== null;
+    const alwaysReport = scheduledPolicy === "always_report";
     // 启动序列:非 scheduled 保持原文(含"先确认接手"/"收到消息就处理并回复"——这两条是
     // 协作场景的核心礼仪);scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
-    const startupSequence = scheduled
-        ? `## 启动序列(静默定时任务)
+    const startupSequence = alwaysReport
+        ? `## 启动序列(每轮汇报定时任务)
+1. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
+2. 执行唤醒提示词里给出的定时指令。
+3. Return exactly one self-contained final report as your runtime final response.
+4. Do not call crew message send; the daemon delivers the final response.
+5. Do not send acknowledgements or progress messages.
+6. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。`
+        : scheduled
+            ? `## 启动序列(静默定时任务)
 1. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
 2. 执行唤醒提示词里给出的定时指令。**默认零输出**:不判断"是否需要先确认/声明接手",本轮没有人在等你回复。
 3. 只有发现异常、需要人处理、或指令明确要求汇报时,才用 \`crew message send --send-draft\` 输出到频道(用法见上面"通信"一节)。
 4. 只有存在需要后续跟进的具体事项时,才用 \`crew task create\` 创建任务。
 5. 无异常时直接结束,不需要任何输出,不必读频道历史(除非指令要求)。`
-        : `## 启动序列
+            : `## 启动序列
 1. 若本轮已带具体来信,先判断是否需要立即确认/提问/声明接手;需要就先用 \`crew message send\` 发出,再去深挖上下文。
 2. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
@@ -39,7 +50,7 @@ export function buildSystemPrompt(ctx) {
     // 消息、没有 task,这条规则字面上无法执行,省略(2026-07-13 复审 Minor 5)。
     const claimRule = scheduled
         ? ""
-        : "\n- **动手干活前必须先 `crew task claim`**;claim 失败就转做别的任务。";
+        : "\n- **除定时任务管理外,动手干活前必须先 `crew task claim`**;claim 失败就转做别的任务。";
     // "一线程一 task 且必须带 --thread"与"进度/产出回本线程,严禁发到顶层"都建立在"本轮有一条
     // 触发消息、线程根即为该消息 id"这个前提上——scheduled run 没有触发消息、没有 thread 锚点,
     // 唯一输出路径就是频道顶层 `--send-draft`,与这两条正面矛盾且 --thread 参数根本填不出来,
@@ -47,9 +58,74 @@ export function buildSystemPrompt(ctx) {
     const threadTaskRule = scheduled
         ? "\n- **静默任务无线程锚点**:只有存在需要人跟进的具体事项时才用 `crew task create --title \"…\"`(无需 `--thread`——本轮没有触发消息可绑)。"
         : `\n- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。被唤醒处理来信时,对这件事**只建一个 task,且必须把它绑到当前线程**:\`crew task create --title "…" --thread <触发你的那条消息 id>\`(那条消息就是线程根)。**一定要带 \`--thread\`**——不带会另起一条飘在顶层的新线程,task 就和你的讨论分家了(这正是要避免的)。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再建会被服务端拒绝(报错会提示你)。`;
-    const progressRule = scheduled
-        ? "\n- **产出走频道顶层**:静默 run 唯一的输出路径是 `crew message send --channel <id> --send-draft`(顶层、无 thread)——本轮没有触发消息,没有线程锚点可回。"
-        : "\n- **进度/产出回本线程**:这件事的认领/进度/完成汇报都用 `crew message send --thread <当前线程根>` 回复在**这个线程里**(线程根 = 触发你的那条消息 id,即 \$CREW_WAKE_MESSAGE_ID)。**严禁把进度发到别的线程或频道顶层。**";
+    const progressRule = alwaysReport
+        ? "\n- **报告交由 daemon 投递**:只返回一个完整最终报告,不要调用 `crew message send`;本轮没有线程锚点。"
+        : scheduled
+            ? "\n- **产出走频道顶层**:静默 run 唯一的输出路径是 `crew message send --channel <id> --send-draft`(顶层、无 thread)——本轮没有触发消息,没有线程锚点可回。"
+            : "\n- **进度/产出回本线程**:这件事的认领/进度/完成汇报都用 `crew message send --thread <当前线程根>` 回复在**这个线程里**(线程根 = 触发你的那条消息 id,即 \$CREW_WAKE_MESSAGE_ID)。**严禁把进度发到别的线程或频道顶层。**";
+    const scheduleManagementRule = scheduled ? "" : `
+
+## 定时任务管理
+当来信要求查看、修改、暂停、恢复、取消或立即执行定时任务时:
+1. 定时任务管理无需 \`crew task claim\`;直接执行下面的查询/管理流程。
+2. 先运行 \`crew schedule list --channel ${ctx.channelId} --agent ${ctx.handle}\` 查询本频道绑定到你自己的候选。
+3. 只有一个明确匹配时,才运行 \`crew schedule update <jobId> ...\` 或对应 pause/resume/cancel/run-now 命令。
+4. 有多个合理候选时,列出候选并先让用户选择;用户选定前不得修改任何任务。
+5. 修改请求不能用 \`crew schedule create\` 代替。完成后回复同一个 job ID 的明确前后变化。`;
+    const voiceRule = alwaysReport
+        ? "- **本轮报告只写在 runtime 最终回复中**:不要调用 `crew message send`;daemon 会把最终回复投递到频道。"
+        : "- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**";
+    const actionRule = scheduled
+        ? `- **判定规则**:直接执行本轮定时指令,执行前不需要 claim。${threadTaskRule}${progressRule}`
+        : `- **判定规则**:定时任务管理直接按上节执行,无需 task claim;其它来信若需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。${threadTaskRule}${progressRule}`;
+    const taskAndScheduleCommands = alwaysReport
+        ? `4. **\`crew task create --channel <id> --title "<标题>"\`** —— 仅为本轮发现的具体后续事项创建任务;本轮没有线程锚点,不要传 \`--thread\`。
+5. **\`crew schedule list --channel <id> --agent <handle>\`** —— 查询本频道指定 agent 的定时任务。
+6. **\`crew schedule update <jobId> ...\`** —— 修改定时任务标题、指令、时间或输出策略。
+7. **\`crew schedule pause|resume|cancel|run-now <jobId>\`** —— 控制定时任务。`
+        : scheduled
+            ? `5. **\`crew task create --channel <id> --title "<标题>"\`** —— 仅为本轮发现的具体后续事项创建任务;本轮没有线程锚点,不要传 \`--thread\`。
+6. **\`crew schedule list --channel <id> --agent <handle>\`** —— 查询本频道指定 agent 的定时任务。
+7. **\`crew schedule update <jobId> ...\`** —— 修改定时任务标题、指令、时间或输出策略。
+8. **\`crew schedule pause|resume|cancel|run-now <jobId>\`** —— 控制定时任务。`
+            : `5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
+6. **\`crew task create --channel <id> --title "<标题>" --thread <当前线程根msgId>\`** —— 新建任务并**绑定到当前线程**。\`--thread\` 传你读到的那条**触发消息 id**(线程根),任务就和讨论同处一个线程。省略 \`--thread\` 会另起新线程,**几乎总是错的——务必带上**。
+7. **\`crew task claim <taskId>\`** —— 除定时任务管理外,执行需要动作的工作前先认领任务。
+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 list --channel <id> --agent <handle>\`** —— 查询本频道指定 agent 的定时任务。
+12. **\`crew schedule update <jobId> ...\`** —— 修改定时任务标题、指令、时间或输出策略。
+13. **\`crew schedule pause|resume|cancel|run-now <jobId>\`** —— 控制定时任务。`;
+    const communicationSection = alwaysReport
+        ? `## 控制面工具 —— crew CLI
+需要读取频道或操作任务时使用 crew CLI;最终报告不得通过消息命令发送。可使用:
+1. **\`crew whoami\`** —— 查看你自己的身份。
+2. **\`crew message read --channel <id>\`** —— 读取频道历史。
+3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。
+${taskAndScheduleCommands}`
+        : `## 通信 —— 只能用 crew CLI
+所有 chat / task 操作必须经 \`crew\` CLI(daemon 已把它注入你的 PATH)。仅可使用以下命令:
+1. **\`crew whoami\`** —— 查看你自己的身份。
+2. **\`crew message read --channel <id>\`** —— 读频道历史(读取即自动推进你的已读/新鲜度游标)。支持 \`--after <seq>\` / \`--limit <n>\`。
+3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。工作中可在自然断点随时用。
+4. **\`crew message send --channel <id>\`** —— 发消息。正文从 stdin 读,用 heredoc 避免 shell 解释引号/反引号/代码块:
+   \`\`\`bash
+   crew message send --channel <id> <<'CREWMSG'
+   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
+   CREWMSG
+   \`\`\`
+   也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <完整线程根消息 id>\`。被唤醒时优先使用环境变量 \`$CREW_WAKE_MESSAGE_ID\` 或唤醒提示里的完整 id,不要手动截短。
+${taskAndScheduleCommands}`;
+    const freshnessRule = alwaysReport
+        ? ""
+        : `
+- **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。`;
+    const interactiveTaskRules = scheduled ? "" : `
+- **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
+- 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。
+- **交接(handoff)**:当你这一环干完、需要别的角色接手时(如开发完成 → 交给 QA 测试),用 \`crew task assign <taskId> --to <下家handle>\` 把任务交接出去,并在线程里给下家足够背景(分支名 / 改动摘要 / 测试建议)。交接后对方会被自动唤醒。**别让任务停在你手里无人跟进**。
+- **分诊(若你是总管)**:若你收到「【分诊请求】」唤醒,说明频道里有一个无人认领的任务需要你按团队职责分派。唤醒内容里已附上团队成员及其职责:判断谁最合适,用 \`crew task assign <taskId> --to <handle>\` 指派给他(若该你自己做就 \`crew task claim\`);确实没人合适时,在频道里 @发起人 说明并给建议,**不要让任务悬空**。`;
     // 协作礼仪:整节都在讲"如何对人主动发声/插话/回报"——scheduled run 没有对话对象,
     // 这节整体不适用,省略(不是"粗暴删",是这节内容本身就是协作场景专属)。
     const collaborationEtiquette = scheduled
@@ -59,17 +135,22 @@ export function buildSystemPrompt(ctx) {
 ## 协作礼仪
 - **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
 - **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
-- **claim 后再动手**:claim 失败立即停手,换一个任务。
+- **除定时任务管理外,claim 后再动手**:claim 失败立即停手,换一个任务。
 - **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
 - **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。`;
     // 沟通风格:原文"收到任务先确认并简述计划;多步工作发简短进度"同样与静默冲突,
     // scheduled 换成明确的"默认不输出"版本。
-    const communicationStyle = scheduled
+    const communicationStyle = alwaysReport
         ? `
 
+## 沟通风格(每轮汇报定时任务)
+不要发送确认或过程消息。只在 runtime 最终回复中给出一次完整、自包含的结果,由 daemon 统一投递。`
+        : scheduled
+            ? `
+
 ## 沟通风格(静默定时任务)
 本轮没有人在等你回复,默认不输出、不叙述过程、不播报进度。只有触发上面"启动序列"里列出的汇报条件时才发消息,内容简明陈述结果/异常即可。`
-        : `
+            : `
 
 ## 沟通风格
 用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
@@ -92,24 +173,7 @@ export function buildSystemPrompt(ctx) {
 - **跨任务协调看实时清单**:用 \`crew task list --mine\` 查你当前所有任务及其状态(谁在排队、谁在评审)。例:你一次只能测一个页面时,据此判断"正在测 #1、#2 排队",在 #2 的工作日志里标注"等 #1 完成"。
 - 需要更多背景时再 \`Read $CREW_HOME/notes/<topic>.md\`;不要一次把所有笔记读进上下文。
 
-## 通信 —— 只能用 crew CLI
-所有 chat / task 操作必须经 \`crew\` CLI(daemon 已把它注入你的 PATH)。仅可使用以下命令:
-1. **\`crew whoami\`** —— 查看你自己的身份。
-2. **\`crew message read --channel <id>\`** —— 读频道历史(读取即自动推进你的已读/新鲜度游标)。支持 \`--after <seq>\` / \`--limit <n>\`。
-3. **\`crew message check --channel <id>\`** —— 非阻塞查看未读数。工作中可在自然断点随时用。
-4. **\`crew message send --channel <id>\`** —— 发消息。正文从 stdin 读,用 heredoc 避免 shell 解释引号/反引号/代码块:
-   \`\`\`bash
-   crew message send --channel <id> <<'CREWMSG'
-   你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
-   CREWMSG
-   \`\`\`
-   也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <完整线程根消息 id>\`。被唤醒时优先使用环境变量 \`$CREW_WAKE_MESSAGE_ID\` 或唤醒提示里的完整 id,不要手动截短。
-5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
-6. **\`crew task create --channel <id> --title "<标题>" --thread <当前线程根msgId>\`** —— 新建任务并**绑定到当前线程**。\`--thread\` 传你读到的那条**触发消息 id**(线程根),任务就和讨论同处一个线程。省略 \`--thread\` 会另起新线程,**几乎总是错的——务必带上**。
-7. **\`crew task claim <taskId>\`** —— 认领任务(动手前必做)。
-8. **\`crew task update <taskId> --status <in_progress|in_review|done>\`** —— 推进任务状态。
-9. **\`crew task unclaim <taskId>\`** —— 释放认领,把任务让给别人。
-10. **\`crew task assign <taskId> --to <handle>\`** —— 把任务指派/交接给另一个 agent(用于交接,见下)。
+${communicationSection}
 
 CLI 成功时打印人类可读文本到 stdout;失败时 stderr 给出错误,并用**退出码**告诉你下一步:
 - \`4\` = 任务已被他人认领 / 不可认领 → 停手,别抢,转做别的。
@@ -117,20 +181,16 @@ CLI 成功时打印人类可读文本到 stdout;失败时 stderr 给出错误,
 - \`3\` = 鉴权失败;\`5\` = 目标不存在;\`2\` = 参数错误。
 
 CRITICAL 规则:
-- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**
+${voiceRule}
 - **一个 shell 命令只跑一个 crew 命令**,读完它的输出,再决定下一条。不要把多个 crew 命令串到一行。${claimRule}
 
-${startupSequence}
+${startupSequence}${scheduleManagementRule}
 
 ## 消息与任务
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
-- **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。${threadTaskRule}${progressRule}
-- **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
-- 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。
-- **交接(handoff)**:当你这一环干完、需要别的角色接手时(如开发完成 → 交给 QA 测试),用 \`crew task assign <taskId> --to <下家handle>\` 把任务交接出去,并在线程里给下家足够背景(分支名 / 改动摘要 / 测试建议)。交接后对方会被自动唤醒。**别让任务停在你手里无人跟进**。
-- **分诊(若你是总管)**:若你收到「【分诊请求】」唤醒,说明频道里有一个无人认领的任务需要你按团队职责分派。唤醒内容里已附上团队成员及其职责:判断谁最合适,用 \`crew task assign <taskId> --to <handle>\` 指派给他(若该你自己做就 \`crew task claim\`);确实没人合适时,在频道里 @发起人 说明并给建议,**不要让任务悬空**。
-- **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。${collaborationEtiquette}${communicationStyle}
+${actionRule}
+${interactiveTaskRules}${freshnessRule}${collaborationEtiquette}${communicationStyle}
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:
@@ -146,7 +206,17 @@ ${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) {
+export function buildScheduledPrompt(channelId, jobPrompt, outputPolicy = "silent_unless_report") {
+    if (outputPolicy === "always_report") {
+        return [
+            "You are executing a scheduled job. No one is waiting for an acknowledgement.",
+            `Scheduled instruction: ${jobPrompt}`,
+            "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.",
+            "Create a crew task only when the result contains a concrete follow-up action.",
+        ].join("\n");
+    }
     return [
         "你正在执行一个静默定时任务(后台运行,频道里没有人在等你回复)。",
         `- 执行这条定时指令: ${jobPrompt}`,

package/dist/runner.js

@@ -11,10 +11,11 @@ import { spawnClaude } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { applyProviderEnv, providerFingerprint } from "./provider-env.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { normalizeEvent, parseLine, extractRunMeta } from "./normalize.js";
+import { normalizeEvent, parseLine, extractFinalText, extractRunMeta } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { toConsoleLines } from "./console.js";
 import { dslog } from "./slog.js";
+import { deliverScheduledReport } from "./scheduled-report.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
 const MEMORY_INJECT_CAP = 6000;
 const ICON = {
@@ -69,9 +70,11 @@ onConsole = () => { }) {
             : !config.resume ? "resume_disabled"
                 : !ws.sessionResume ? "first_run"
                     : resuming ? (nearBudget ? "warm_resume_near_budget" : "warm_resume")
-                        : rotatedForBudget ? "rotated_for_budget"
-                            : "warm_window_expired_or_model_changed",
+                        : prior?.lastExitOk === false ? "prior_run_crashed"
+                            : rotatedForBudget ? "rotated_for_budget"
+                                : "warm_window_expired_or_model_changed",
         prior_context_tokens: prior?.contextTokens ?? null,
+        prior_last_exit_ok: prior?.lastExitOk ?? null,
         budget_tokens: config.sessionBudgetTokens,
     });
     const systemPrompt = buildSystemPrompt({
@@ -80,7 +83,7 @@ onConsole = () => { }) {
         agentId: cred.agentId,
         homeDir: ws.dir,
         productName: config.productName,
-        ...(input.scheduled ? { scheduled: true } : {}),
+        ...(input.scheduled ? { scheduledOutputPolicy: input.scheduled.outputPolicy } : {}),
         // 只注入 MEMORY.md 的索引/角色部分(截断),避免上下文膨胀;明细让 agent 按需读 notes/。
         memory: ws.memory.length > MEMORY_INJECT_CAP
             ? ws.memory.slice(0, MEMORY_INJECT_CAP) + "\n…(MEMORY.md 过长已截断,详情用 Read 读 $CREW_HOME/MEMORY.md 或 notes/)"
@@ -134,6 +137,7 @@ onConsole = () => { }) {
             : {}),
         // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
         ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
+        ...(input.scheduled ? { CREW_SCHEDULE_OUTPUT_POLICY: input.scheduled.outputPolicy } : {}),
     };
     // provider custom = BYOC:剔除全局 ANTHROPIC_*/Bedrock 残留 + 按鉴权方式注入端点与密钥,
     // 与机器全局 Claude 登录态/配置互不干扰(细节见 provider-env.ts)。
@@ -206,15 +210,9 @@ onConsole = () => { }) {
             activities.push(a);
             onActivity(a);
         }
-        const item = evt.item;
-        if (evt.type === "item.completed" && item?.type === "agent_message" && item.text?.trim()) {
-            finalText = item.text.trim();
-        }
-        // kimi:最后一条带正文的 assistant 行即最终回答(kimi 无 result/turn.completed 事件)
-        const kimiMsg = evt;
-        if (kimiMsg.role === "assistant" && !kimiMsg.type && typeof kimiMsg.content === "string" && kimiMsg.content.trim()) {
-            finalText = kimiMsg.content.trim();
-        }
+        const extracted = extractFinalText(evt);
+        if (extracted)
+            finalText = extracted;
         // 同一事件再透传为终端 console 行(独立于状态活动,内容不压缩)。
         for (const c of toConsoleLines(evt))
             onConsole(c);
@@ -226,9 +224,13 @@ onConsole = () => { }) {
         process.stderr.write(d);
         stderrTail = (stderrTail + String(d)).slice(-STDERR_TAIL_CAP);
     });
-    const { exitCode, spawnError } = await awaitExit(child);
+    const { exitCode, spawnError, terminationSignal } = await awaitExit(child);
     // spawn 本身失败(如 PATH 里没有 runtime 二进制)没有 stderr,把错误并入尾部供上报。
-    const errorTail = [stderrTail.trim(), spawnError].filter(Boolean).join(" ").trim();
+    const errorTail = [
+        stderrTail.trim(),
+        spawnError,
+        terminationSignal ? `terminated by ${terminationSignal}` : undefined,
+    ].filter(Boolean).join(" ").trim();
     const finish = exitActivity(runtime, exitCode, errorTail);
     if (finish) {
         activities.push(finish);
@@ -236,7 +238,7 @@ onConsole = () => { }) {
         if (finish.kind === "error")
             onConsole({ stream: "error", text: `✖ ${finish.detail ?? finish.label}` });
     }
-    if (!input.suppressFallback && (runtime === "codex" || runtime === "kimi") && exitCode === 0 && !sentViaCrew && finalText) {
+    if (!input.scheduled && (runtime === "codex" || runtime === "kimi") && exitCode === 0 && !sentViaCrew && finalText) {
         // force:兜底回帖锚定本轮触发消息的线程,语义上必须送达;不 force 时 agent(-p 单发不跑
         // crew read)游标落后,回帖会被 freshness hold 成 draft(202)而永远不可见。
         const sent = await sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
@@ -269,6 +271,8 @@ onConsole = () => { }) {
             turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
             model: currentModel,
             providerFingerprint: providerFp,
+            // 非零退出(崩溃/超窗/被杀)标记本会话不健康 → 下轮 pickResumeId 强制冷启动,不再续这个坏会话。
+            lastExitOk: exitCode === 0,
             ...(contextTokens != null ? { contextTokens } : {}),
         });
     }
@@ -277,7 +281,47 @@ onConsole = () => { }) {
         process.stdout.write(`📊 tokens: in=${u.inputTokens} out=${u.outputTokens} cache_read=${u.cacheReadTokens} cache_create=${u.cacheCreationTokens}` +
             `${u.costUsd != null ? ` cost=$${u.costUsd.toFixed(4)}` : ""} ${resuming ? "(resumed)" : rotatedForBudget ? "(rotated: budget)" : "(fresh)"}\n`);
     }
-    return { exitCode, activities, model: observedModel, runtime, resumed: resuming, sessionId, ...(usage ? { usage } : {}) };
+    // 所有可能抛错的本地收尾完成后再投递，避免“报告已发出但随后落盘失败”被 serve catch
+    // 当成另一轮失败再次通知。deliverScheduledReport 自身吞掉网络异常并返回可持久化 outcome。
+    const report = input.scheduled
+        ? await deliverScheduledReport({
+            policy: input.scheduled.outputPolicy,
+            title: input.scheduled.title,
+            exitCode,
+            finalText,
+            errorMessage: errorTail || null,
+            send: (content) => sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
+                content,
+                force: true,
+            }),
+        })
+        : undefined;
+    return {
+        exitCode,
+        activities,
+        model: observedModel,
+        runtime,
+        resumed: resuming,
+        sessionId,
+        errorMessage: errorTail || null,
+        ...(usage ? { usage } : {}),
+        ...(report ? { report } : {}),
+    };
+}
+/** runAgent 在 workspace/spawn 等前置阶段抛错时的可见失败兜底。 */
+export async function reportScheduledStartFailure(config, input) {
+    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle);
+    return deliverScheduledReport({
+        policy: input.scheduled.outputPolicy,
+        title: input.scheduled.title,
+        exitCode: -1,
+        finalText: null,
+        errorMessage: input.errorMessage,
+        send: (content) => sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
+            content,
+            force: true,
+        }),
+    });
 }
 /** 随 error 活动上送的 stderr 尾部上限。 */
 const STDERR_TAIL_CAP = 2000;
@@ -296,7 +340,9 @@ export function awaitExit(child) {
             resolve(r);
         };
         child.on("error", (e) => settle({ exitCode: -1, spawnError: e.message }));
-        child.on("close", (code) => settle({ exitCode: code ?? 0 }));
+        child.on("close", (code, signal) => settle(code === null
+            ? { exitCode: 128, terminationSignal: signal ?? "unknown" }
+            : { exitCode: code }));
     });
 }
 /**

package/dist/scheduled-report.js

@@ -0,0 +1,47 @@
+export function normalizeScheduledPolicy(value) {
+    return value === "always_report" ? "always_report" : "silent_unless_report";
+}
+export function normalizeScheduledContext(input) {
+    return {
+        jobId: input.jobId,
+        runId: input.runId,
+        title: input.title?.trim() || "Scheduled job",
+        outputPolicy: normalizeScheduledPolicy(input.outputPolicy),
+    };
+}
+export async function deliverScheduledReport(input) {
+    const title = input.title.trim() || "Scheduled job";
+    let source = "none";
+    let content = null;
+    if (input.exitCode !== 0) {
+        source = "failure_notice";
+        const detail = input.errorMessage?.trim().slice(0, 500);
+        content = `Scheduled job "${title}" failed${detail ? `: ${detail}` : ` (exit ${input.exitCode})`}.`;
+    }
+    else if (input.policy === "always_report") {
+        if (input.finalText?.trim()) {
+            source = "runtime_final";
+            content = input.finalText.trim();
+        }
+        else {
+            source = "empty_notice";
+            content = `Scheduled job "${title}" completed without a usable report.`;
+        }
+    }
+    if (!content) {
+        return { required: false, attempted: false, delivered: false, source: "none" };
+    }
+    try {
+        const sent = await input.send(content);
+        return {
+            required: true,
+            attempted: true,
+            delivered: sent.delivered,
+            status: sent.status,
+            source,
+        };
+    }
+    catch {
+        return { required: true, attempted: true, delivered: false, source };
+    }
+}

package/dist/scheduled-run-report.js

@@ -0,0 +1,48 @@
+function fields(input) {
+    return {
+        scheduled_run_id: input.scheduledRunId,
+        run_id: input.runId,
+        agent_handle: input.agentHandle,
+        channel_id: input.channelId,
+        exit_code: input.exitCode,
+        ...(input.runtime ? { runtime: input.runtime } : {}),
+        ...(input.model ? { model: input.model } : {}),
+    };
+}
+export function reportScheduledRunComplete(socket, input, log) {
+    if (!socket) {
+        log("scheduled_run.complete_send_failed", "定时任务完成回报未发送:控制面连接不可用", {
+            level: "WARN", ...fields(input), error_message: "control socket unavailable",
+        });
+        return;
+    }
+    const payload = JSON.stringify({
+        type: "agent:run-complete",
+        agentHandle: input.agentHandle,
+        channelId: input.channelId,
+        scheduledRunId: input.scheduledRunId,
+        exitCode: input.exitCode,
+        ...(input.runtime ? { runtime: input.runtime } : {}),
+        ...(input.model !== undefined ? { model: input.model } : {}),
+        ...(input.resumed !== undefined ? { resumed: input.resumed } : {}),
+        ...(input.errorMessage ? { errorMessage: input.errorMessage } : {}),
+        ...(input.usage ? { usage: input.usage } : {}),
+        ...(input.report ? { report: input.report } : {}),
+    });
+    try {
+        socket.send(payload, (error) => {
+            if (error) {
+                log("scheduled_run.complete_send_failed", "定时任务完成回报发送失败", {
+                    level: "WARN", ...fields(input), error_message: error.message,
+                });
+                return;
+            }
+            log("scheduled_run.complete_sent", "定时任务完成回报已发送", fields(input));
+        });
+    }
+    catch (error) {
+        log("scheduled_run.complete_send_failed", "定时任务完成回报发送失败", {
+            level: "WARN", ...fields(input), error_message: error.message,
+        });
+    }
+}

package/dist/serve.js

@@ -6,22 +6,30 @@ import { WebSocket } from "ws";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
-import { runAgent } from "./runner.js";
+import { reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello } from "./machine-info.js";
+import { collectMachineHello, DAEMON_CAPABILITIES } 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";
 // 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) {
+    const query = new URLSearchParams({ key: machineToken });
+    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 = config.serverUrl.replace(/^http/, "ws") +
-        `/daemon/connect?key=${encodeURIComponent(config.machineToken)}`;
+    const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken);
     let stopped = false;
     let ws = null;
     let backoff = 1000;
@@ -55,7 +63,7 @@ export function serve(config, opts = {}) {
         if (q && q.length)
             (q.shift())();
     };
-    const log = (s) => process.stdout.write(s + "\n");
+    const log = (s) => process.stdout.write(formatDaemonLogLine(s) + "\n");
     function connect() {
         if (stopped)
             return;
@@ -155,7 +163,9 @@ export function serve(config, opts = {}) {
                 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 ? msg.scheduledRun : null;
+            const scheduled = msg.reason === "scheduled_job" && msg.scheduledRun
+                ? normalizeScheduledContext(msg.scheduledRun)
+                : null;
             const threadId = msg.wake?.threadId;
             const taskKey = scheduled ? scheduled.runId : (threadId ?? msg.channelId);
             const key = `${msg.agentHandle}:${taskKey}`;
@@ -257,7 +267,7 @@ export function serve(config, opts = {}) {
                     ? `crew thread read`
                     : `crew message read --channel ${msg.channelId}`;
                 const wakeText = scheduled
-                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "")
+                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "", scheduled.outputPolicy)
                     : (msg.wake?.content
                         ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
                         : undefined);
@@ -266,7 +276,9 @@ export function serve(config, opts = {}) {
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
                     runId, // 贯穿 SLS 日志的单轮关联键
-                    ...(scheduled ? { suppressFallback: true, scheduled: true } : {}),
+                    ...(scheduled ? {
+                        scheduled: { title: scheduled.title, outputPolicy: scheduled.outputPolicy },
+                    } : {}),
                     // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
                     ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
                     ...(wakeText ? { wake: wakeText } : {}),
@@ -295,20 +307,13 @@ export function serve(config, opts = {}) {
                 }
                 // 静默定时 run:结构化完成回报(驱动 server 端 scheduled_run/job 状态落库,§5.5)
                 if (scheduled) {
-                    try {
-                        ws?.send(JSON.stringify({
-                            type: "agent:run-complete",
-                            agentHandle: msg.agentHandle,
-                            channelId: msg.channelId,
-                            scheduledRunId: scheduled.runId,
-                            exitCode: result.exitCode,
-                            runtime: result.runtime,
-                            model: result.model,
-                            resumed: result.resumed,
-                            ...(result.usage ? { usage: result.usage } : {}),
-                        }));
-                    }
-                    catch { /* ws 非 OPEN;server 端 reaper 会按超时回收 */ }
+                    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.end 是排查「任务没跑完就本轮结束」的核心证据:退出码 + 时长 + 最后活动 +
                 // 是否 resume + 用量。exit_code!=0 或时长异常短都值得追。
@@ -350,17 +355,21 @@ export function serve(config, opts = {}) {
                     error_message: e.message, error_stack: e.stack,
                 });
                 if (scheduled) {
+                    let report;
                     try {
-                        ws?.send(JSON.stringify({
-                            type: "agent:run-complete",
-                            agentHandle: msg.agentHandle,
+                        report = await reportScheduledStartFailure(config, {
+                            handle: msg.agentHandle,
                             channelId: msg.channelId,
-                            scheduledRunId: scheduled.runId,
-                            exitCode: -1,
+                            scheduled,
                             errorMessage: e.message,
-                        }));
+                        });
                     }
-                    catch { /* ws 非 OPEN;reaper 兜底 */ }
+                    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);
                 }
             }
             finally {

package/dist/session.js

@@ -30,6 +30,7 @@ export async function readSession(runDir) {
             model: typeof o.model === "string" ? o.model : null,
             providerFingerprint: typeof o.providerFingerprint === "string" ? o.providerFingerprint : null,
             ...(typeof o.contextTokens === "number" && o.contextTokens >= 0 ? { contextTokens: o.contextTokens } : {}),
+            ...(typeof o.lastExitOk === "boolean" ? { lastExitOk: o.lastExitOk } : {}),
         };
     }
     catch {
@@ -60,6 +61,10 @@ export function pickResumeId(prior, now, warmMs, currentModel = null, budgetToke
     // 下,--resume 会直接报错,必须冷启动。
     if ((prior.providerFingerprint ?? null) !== currentProviderFingerprint)
         return null;
+    // 上轮崩溃/超窗/被杀:会话大概率已污染(或就是太大),续用几乎必再崩。强制冷启动斩断循环——
+    // 这条不依赖 token 记账是否准确(OOM/SIGKILL 时没有 usage,预算判断会漏,此条兜底)。
+    if (prior.lastExitOk === false)
+        return null;
     if (warmMs > 0 && now - prior.lastRunAt > warmMs)
         return null;
     if (budgetTokens > 0 && (prior.contextTokens ?? 0) >= budgetTokens)

package/package.json

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