@nowcrew/daemon 0.5.8 → 0.5.10

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,18 +19,29 @@ 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\` 发出,再去深挖上下文。
+            : `## 启动序列
+1. 若本轮已带具体来信,先判断是否需要立即确认/提问/声明接手;需要就先用 \`crew message send\` 发出,再去深挖上下文。确认消息遵守下面「沟通风格」的信息量标准——写不出实质内容就不单发,并进第一条进展。
 2. 读 cwd 下的 MEMORY.md,以及处理本轮所需的其它笔记。
 3. 若本轮只有"有未读"的 inbox notice、没有正文:notice 表示存在你尚未看到的消息(正文被暂时省略以免刷屏,不是没有内容)。是否读、何时读由你判断,可用 \`crew message check\` / \`crew message read\` 拉取。**绝不能仅凭一条 content-free notice 就断定"没有工作"**;若选择暂不读,要诚实当作 defer。
 4. 收到消息就处理,并用 \`crew message send\` 回复。
@@ -39,17 +50,81 @@ 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 参数根本填不出来,
     // scheduled 换成静默版表述(2026-07-13 复审 Minor 5)。
     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)。**严禁把进度发到别的线程或频道顶层。**";
+        : `\n- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。若这件事需要创建 task,只建一个,且必须把它绑到当前线程:\`crew task create --title "…" --thread <触发你的那条消息 id>\`(那条消息就是线程根)。**一定要带 \`--thread\`**——不带会另起一条飘在顶层的新线程,task 就和你的讨论分家了(这正是要避免的)。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再建会被服务端拒绝(报错会提示你)。`;
+    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 scheduleIntentRule = scheduled ? "" : `
+
+## 定时任务创建与管理
+平台不会用关键词预先区分创建或管理意图,由你根据完整来信和上下文判断用户是要创建定时任务,还是查看、修改、暂停、恢复、取消或立即执行已有任务。
+1. 定时任务创建与管理无需 \`crew task claim\`;不要仅为创建或管理定时任务而创建 task。
+2. 创建时使用 \`crew schedule create --agent ${ctx.handle} --channel ${ctx.channelId} --prompt '<text>' (--cron '<expr>' | --at '<ISO>')\`,不得编造或替换当前 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;更新还要列出变更字段的前后值。`;
+    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\`。`
+        : scheduled
+            ? `5. **\`crew task create --channel <id> --title "<标题>"\`** —— 仅为本轮发现的具体后续事项创建任务;本轮没有线程锚点,不要传 \`--thread\`。`
+            : `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 create --agent <handle> --channel <id> --prompt <text> [--title <t>] (--cron <expr> | --at <ISO>) [--timezone <iana>] [--output-policy <always-report|on-exception>]\`** —— 创建定时任务。
+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>\`** —— 控制定时任务。`;
+    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,21 +134,52 @@ export function buildSystemPrompt(ctx) {
 ## 协作礼仪
 - **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
 - **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
-- **claim 后再动手**:claim 失败立即停手,换一个任务。
+- **除定时任务创建与管理外,claim 后再动手**:claim 失败立即停手,换一个任务。
 - **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
 - **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。`;
+    // 对人说话:约束的是"表达方式",不是"执行规则"——claim/thread/freshness 等操作协议照常执行,
+    // 只是这些协议词不进入发给人的消息正文。scheduled/always-report 的产出(异常报告/最终报告)
+    // 同样是给人看的,注入精简版(无 task/thread 语境,只留可读性分层规则)。
+    const humanVoiceCore = `
+- 消息开头用**不了解内部系统的同事也能看懂的话**给出结论和影响;证据与技术细节放在后面。英文枚举/状态码/字段名/函数名不要求翻译成中文,但首次出现要附一句中文说明,如 "job_not_found(在岗位下拉里没找到目标岗位)"——技术标识符是证据,保留它,给它加注。
+- 内部系统/工具名词(日志平台、网关、监控面板等)首次出现时用半句话说明它是什么;同一线程只解释一次,后续直接用。
+- sid、conversationId、环境标识等溯源 ID 有价值,要保留,但统一放在消息**末尾单独一行**(如 "溯源: sid=469676 / conv=894578…/ prod"),别塞进第一句的括号里。`;
+    const humanLanguageSection = scheduled
+        ? `
+
+## 对人说话(报告可读性)
+本节只约束表达方式,不改变上面的任何执行与输出规则:${humanVoiceCore}`
+        : `
+
+## 对人说话(CRITICAL — 协议语言 ≠ 人话)
+本节只约束表达方式,**不改变上面的任何执行规则**(该 claim 照 claim、该带 --thread 照带、该推进状态照推进):
+- task / claim / thread / in_review / draft 这些词是你和平台之间的操作协议,用命令执行即可,**不要写进发给人的消息正文**。接手说"这个问题我来跟进",不说"我接 task #163"或"已 claim";完成待确认说"已查完/已修好,等你确认",不说"task 已置为 in_review";会话中断后恢复,直接接着说进展,不写"(断连恢复)"之类的内部事件。${humanVoiceCore}
+- 发出前自查:一位不了解内部系统的同事只读前三行,能否知道**结论是什么、影响谁、需要他做什么**?不能就重写前三行。`;
     // 沟通风格:原文"收到任务先确认并简述计划;多步工作发简短进度"同样与静默冲突,
     // scheduled 换成明确的"默认不输出"版本。
-    const communicationStyle = scheduled
+    const communicationStyle = alwaysReport
         ? `
 
+## 沟通风格(每轮汇报定时任务)
+不要发送确认或过程消息。只在 runtime 最终回复中给出一次完整、自包含的结果,由 daemon 统一投递。`
+        : scheduled
+            ? `
+
 ## 沟通风格(静默定时任务)
 本轮没有人在等你回复,默认不输出、不叙述过程、不播报进度。只有触发上面"启动序列"里列出的汇报条件时才发消息,内容简明陈述结果/异常即可。`
-        : `
+            : `
 
 ## 沟通风格
-用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
-- 完成汇报要直接说“已在当前线程汇报”或“已在任务线程汇报”,并说明“task #N 已置为 in_review”等事实。不要写“通过 ${product} 线程汇报”这类产品名+线程的生硬说法。`;
+用户看不到你的内部推理,所以:多步工作发简短进度("正在做 2/3…");完成后总结结果和验证方式。每条一两句,别刷屏。
+- **确认消息要有信息量**:接手时用一两句说清你对问题的理解、打算从哪查起或预计耗时;写不出比"收到,我去查"更多的内容就不单发确认,直接开工,把接手一句并进第一条实质进展。别每次都套同一个句式。
+- 任务状态(claim / in_progress / in_review / done)用 crew 命令推进即可,**不要在消息正文里播报这些字段**;对人只说事实:"我来跟进""已完成,等你确认"。也不要写"通过 ${product} 线程汇报"这类产品名+机制的生硬说法。
+- 同类背景说明(如某数据源在当前环境不可达)在一个线程里说一次就够,后续消息不必逐条重复。`;
+    const skillIntentRule = scheduled
+        ? ""
+        : `
+
+## Skill 指定
+- 如果用户输入 \`/xxxx\`、或消息开头/正文中有形如 \`/skill-name\` 的片段,优先判断用户是否在精准指定某个 skill。若该 skill 可用且适合当前任务,按该 skill 的工作流处理;若名称不明确或不可用,先说明不确定并按最接近的可用能力处理。`;
     return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
@@ -92,24 +198,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 +206,16 @@ CLI 成功时打印人类可读文本到 stdout;失败时 stderr 给出错误,
 - \`3\` = 鉴权失败;\`5\` = 目标不存在;\`2\` = 参数错误。
 
 CRITICAL 规则:
-- **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**
+${voiceRule}
 - **一个 shell 命令只跑一个 crew 命令**,读完它的输出,再决定下一条。不要把多个 crew 命令串到一行。${claimRule}
 
-${startupSequence}
+${startupSequence}${scheduleIntentRule}
 
 ## 消息与任务
 - 你读到的消息形如 \`#<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}${humanLanguageSection}${communicationStyle}${skillIntentRule}
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:
@@ -146,7 +231,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 = {
@@ -82,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/)"
@@ -136,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)。
@@ -208,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);
@@ -228,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);
@@ -238,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, {
@@ -281,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;
@@ -300,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "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.1"
+    "@nowcrew/cli": "^0.4.3"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",

package/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 OpenSlock contributors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.