@nowcrew/daemon 0.4.4 → 0.5.6

package/dist/config.js

@@ -33,6 +33,10 @@ export function loadConfig(env = process.env) {
         dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)
         resume: env.CREW_RESUME !== "off" && env.CREW_RESUME !== "0", // 默认开启;一键回退现状用 CREW_RESUME=off
         resumeWarmMs: env.CREW_RESUME_WARM_MS != null ? Number(env.CREW_RESUME_WARM_MS) : 3_600_000, // 默认 1h
-        productName: env.CREW_PRODUCT_NAME ?? "nowcrew",
+        // 会话预算轮换:hard 120k 触发冷启动轮换;soft 90k 先提醒蒸馏 work-log;30 轮为 usage 缺失的兜底
+        sessionBudgetTokens: env.CREW_SESSION_BUDGET_TOKENS != null ? Number(env.CREW_SESSION_BUDGET_TOKENS) : 120_000,
+        sessionSoftTokens: env.CREW_SESSION_SOFT_TOKENS != null ? Number(env.CREW_SESSION_SOFT_TOKENS) : 90_000,
+        sessionMaxTurns: env.CREW_SESSION_MAX_TURNS != null ? Number(env.CREW_SESSION_MAX_TURNS) : 30,
+        productName: env.CREW_PRODUCT_NAME ?? "nowwork",
     };
 }

package/dist/list-models.js

@@ -1,6 +1,9 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-const execFileP = promisify(execFile);
+import { isWin } from "./platform.js";
+const execFileRaw = promisify(execFile);
+// win32 上 npm CLI 是 .cmd shim,execFile 需 shell 才能执行;参数全是固定字面量,无注入面。
+const execFileP = (bin, args) => execFileRaw(bin, args, { shell: isWin() });
 export async function listRuntimeModels(runtime) {
     switch (runtime) {
         case "codex":

package/dist/machine-info.js

@@ -1,8 +1,9 @@
 /**
  * 采集本机信息上报给控制面 (machine:hello):hostname / os / daemon 版本 / 已装 runtimes。
- * runtimes 探测靠 `which <bin>`,只报真实可执行的 CLI(用于展示 Detected Runtimes)。
+ * runtimes 探测靠 `which <bin>`(win32 用 `where`),只报真实可执行的 CLI(用于展示 Detected Runtimes)。
  */
 import { hostname, arch, platform } from "node:os";
+import { lookupCmd } from "./platform.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { readFileSync } from "node:fs";
@@ -24,7 +25,7 @@ const RUNTIME_BINS = [
 ];
 async function isInstalled(bin) {
     try {
-        await execFileP("which", [bin]);
+        await execFileP(lookupCmd(), [bin]);
         return true;
     }
     catch {

package/dist/normalize.js

@@ -4,6 +4,18 @@
  * 这是 daemon 的关键职责:前端/server 看到的是"在读历史/领任务/发消息",而非裸 Bash。
  * 纯函数,无 IO,完整单测。
  */
+/**
+ * Strip /bin/zsh -lc, /bin/sh -c, or /bin/bash -lc shell wrappers (single OR double quotes),
+ * including multi-line heredoc forms. [\s\S]+ matches across newlines. Backreference \1 ensures
+ * opening and closing quotes match. classifyCommand requires the result to START with the crew
+ * prefix, keeping false-positive risk low (e.g. echo "crew message send" stays as tool).
+ * Codex runtime uses zsh/bash -lc and switches between single/double quotes depending on context
+ * (e.g. heredoc <<'CREWMSG' triggers double-quote wrapper: /bin/zsh -lc "cmd").
+ */
+function unwrapShellCommand(command) {
+    const m = command.match(/^\/bin\/(?:zsh\s+-lc|sh\s+-c|bash\s+-lc)\s+(['"])([\s\S]+)\1$/);
+    return m?.[2] ?? command;
+}
 /** 把一条 Bash 命令归类为语义活动 (仅看 crew 子命令)。 */
 export function classifyCommand(command) {
     const c = command.trim();
@@ -45,8 +57,7 @@ export function normalizeEvent(event) {
     }
     if (e.type === "item.completed" && e.item?.type === "command_execution" && e.item.command?.trim()) {
         const command = e.item.command.trim();
-        const shell = command.match(/^\/bin\/zsh -lc '(.+)'$/);
-        return [classifyCommand(shell?.[1] ?? command)];
+        return [classifyCommand(unwrapShellCommand(command))];
     }
     if (e.type === "turn.completed") {
         return [{ kind: "done", label: "本轮结束" }];

package/dist/platform.js

@@ -0,0 +1,8 @@
+/**
+ * 平台差异集中点(win32 vs unix)。
+ * Windows 三个坑:没有 `which`(用 `where`);npm 全局 CLI 是 .cmd shim,
+ * spawn/execFile 不带 shell 无法执行(Node 18.20+ 直接拒绝);shebang 脚本不可执行。
+ */
+export const isWin = (p = process.platform) => p === "win32";
+/** 探测可执行文件用的命令:win32 = where,其余 = which。 */
+export const lookupCmd = (p = process.platform) => (isWin(p) ? "where" : "which");

package/dist/prompt.js

@@ -1,12 +1,79 @@
 /**
- * 系统提示词与唤醒提示词构造(nowcrew 自有设计)。
+ * 系统提示词与唤醒提示词构造(nowwork 自有设计)。
  *
- * 描述的是 nowcrew 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
+ * 描述的是 nowwork 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
+/** work-log 注入上限(字符):防冷启动注入随文件膨胀。超限保头(目标/结论)+尾(最近进展),
+ *  截中段并提示读全文——全文仍在盘上,只限"默认推送量"不限"可获取量"。纯函数。 */
+export const WORKLOG_INJECT_CAP = 8000;
+const WORKLOG_HEAD = 4800;
+const WORKLOG_TAIL = 3000;
+export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
+    if (workLog.length <= cap)
+        return workLog;
+    const head = workLog.slice(0, WORKLOG_HEAD);
+    const tail = workLog.slice(-WORKLOG_TAIL);
+    return `${head}\n…(work-log 过长已截去中段,全文用 Read 读 $CREW_TASK_LOG)\n${tail}`;
+}
 export function buildSystemPrompt(ctx) {
-    const product = ctx.productName ?? "nowcrew";
+    const product = ctx.productName ?? "nowwork";
+    const scheduled = ctx.scheduled ?? false;
+    // 启动序列:非 scheduled 保持原文(含"先确认接手"/"收到消息就处理并回复"——这两条是
+    // 协作场景的核心礼仪);scheduled 换成静默版,不出现任何"先确认/先回复"的措辞。
+    const startupSequence = 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。
+4. 收到消息就处理,并用 \`crew message send\` 回复。
+5. **做完你负责的所有事再停。** 多步任务(调研/改码/测试)要全部完成、汇报结果后再停。新消息会在你存活期间自动送达,无需轮询等待。`;
+    // "动手干活前必须先 claim"是协作场景的强约束(有 task 可 claim);scheduled run 没有触发
+    // 消息、没有 task,这条规则字面上无法执行,省略(2026-07-13 复审 Minor 5)。
+    const claimRule = scheduled
+        ? ""
+        : "\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)。**严禁把进度发到别的线程或频道顶层。**";
+    // 协作礼仪:整节都在讲"如何对人主动发声/插话/回报"——scheduled run 没有对话对象,
+    // 这节整体不适用,省略(不是"粗暴删",是这节内容本身就是协作场景专属)。
+    const collaborationEtiquette = scheduled
+        ? ""
+        : `
+
+## 协作礼仪
+- **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
+- **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
+- **claim 后再动手**:claim 失败立即停手,换一个任务。
+- **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
+- **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。`;
+    // 沟通风格:原文"收到任务先确认并简述计划;多步工作发简短进度"同样与静默冲突,
+    // scheduled 换成明确的"默认不输出"版本。
+    const communicationStyle = scheduled
+        ? `
+
+## 沟通风格(静默定时任务)
+本轮没有人在等你回复,默认不输出、不叙述过程、不播报进度。只有触发上面"启动序列"里列出的汇报条件时才发消息,内容简明陈述结果/异常即可。`
+        : `
+
+## 沟通风格
+用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
+- 完成汇报要直接说“已在当前线程汇报”或“已在任务线程汇报”,并说明“task #N 已置为 in_review”等事实。不要写“通过 ${product} 线程汇报”这类产品名+线程的生硬说法。`;
     return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
@@ -51,50 +118,44 @@ CLI 成功时打印人类可读文本到 stdout;失败时 stderr 给出错误,
 
 CRITICAL 规则:
 - **始终只通过 crew CLI 发声。在 crew 命令之外产生的任何文字都不会送达任何人。**
-- **一个 shell 命令只跑一个 crew 命令**,读完它的输出,再决定下一条。不要把多个 crew 命令串到一行。
-- **动手干活前必须先 \`crew task claim\`**;claim 失败就转做别的任务。
+- **一个 shell 命令只跑一个 crew 命令**,读完它的输出,再决定下一条。不要把多个 crew 命令串到一行。${claimRule}
 
-## 启动序列
-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\` 回复。
-5. **做完你负责的所有事再停。** 多步任务(调研/改码/测试)要全部完成、汇报结果后再停。新消息会在你存活期间自动送达,无需轮询等待。
+${startupSequence}
 
 ## 消息与任务
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
-- **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。
-- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。被唤醒处理来信时,对这件事**只建一个 task,且必须把它绑到当前线程**:\`crew task create --title "…" --thread <触发你的那条消息 id>\`(那条消息就是线程根)。**一定要带 \`--thread\`**——不带会另起一条飘在顶层的新线程,task 就和你的讨论分家了(这正是要避免的)。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再建会被服务端拒绝(报错会提示你)。
-- **进度/产出回本线程**:这件事的认领/进度/完成汇报都用 \`crew message send --thread <当前线程根>\` 回复在**这个线程里**(线程根 = 触发你的那条消息 id,即 \$CREW_WAKE_MESSAGE_ID)。**严禁把进度发到别的线程或频道顶层。**
+- **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 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)。
-
-## 协作礼仪
-- **尊重正在进行的对话**:人类正与他人一来一回时,除非明确 @你或显然在叫你,否则不要插话。
-- **只有真正干活的人来汇报**:别替别人总结或冒领他们的工作。
-- **claim 后再动手**:claim 失败立即停手,换一个任务。
-- **停止前检查你欠的具体阻塞项**:若你还欠某人一个 handoff/review/决定/回复且正卡着对方,先发一条最小可行动消息再停。
-- **少发废话**:只在有可行动内容时发消息,不要播报"我在等/我空闲"。
-
-## 沟通风格
-用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
-- 完成汇报要直接说“已在当前线程汇报”或“已在任务线程汇报”,并说明“task #N 已置为 in_review”等事实。不要写“通过 ${product} 线程汇报”这类产品名+线程的生硬说法。
+- **freshness/draft**:发送若被保存为 draft(kind=held),要么重读后用普通 send 改写,要么用 \`crew message send --send-draft\` 原样发出(不要在改内容时用 --send-draft)。${collaborationEtiquette}${communicationStyle}
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:
 1. **MEMORY.md = 索引 + 角色**:指向你全部知识的目录。系统每次已把它(截断索引版)注入到本提示词末尾,**通常不必再去读整文件**;要某领域明细时再 \`Read $CREW_HOME/notes/<file>.md\`。别一次把所有 notes 读进上下文。
 2. **notes/<domain>.md = 明细**:领域知识、用户偏好、频道说明、经验教训(\`notes/lessons.md\`)。**任务进行中只读不写**(多个并行运行同时写会冲突)。
-3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。
+3. **本任务 work-log = \`$CREW_TASK_LOG\`**:每任务一份(别的运行不会碰),记当前阶段/下一步/卡点/关键结论。系统已把它的当前内容注入末尾让你续上;有进展就更新它——这是你**唯一**该在任务中持续写的记忆文件。**work-log 是现状快照,不是流水账**:保持 ≤100 行,更新时重写全文替换过时内容,不要无限追加(过长会被注入截断)。
 
 **沉淀与瘦身由系统触发,不要平时做**:任务被改为 done/closed 时,系统会单独唤醒你收尾——那时才把可复用经验从 work-log 提炼进 \`notes/lessons.md\`、更新 MEMORY.md 索引、并清掉该任务的 work-log。平时别动 MEMORY.md/notes,既防并行冲突,也防 MEMORY.md 膨胀。
 
 **为什么(CRITICAL)**:上下文会被周期压缩;你的恢复力来自——注入的 MEMORY.md 索引(始终精简)+ 本任务 work-log + 按需读 notes,而**不是**把一切堆进 MEMORY.md。
 ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memory}` : ""}${ctx.workLog ? `\n## [注入] 本任务 work-log(续上进度;更新写到 $CREW_TASK_LOG)\n${ctx.workLog}` : ""}`;
 }
+/** 静默定时任务的唤醒提示词:不注入协作礼仪/线程提示;默认零输出(设计文档 §5.4)。
+ *  汇报用 --send-draft:绕过 freshness hold(-p 单发不跑 crew read,游标落后,
+ *  普通 send 会被 202 扣成 draft——监控告警绝不能被静默扣留)。 */
+export function buildScheduledPrompt(channelId, jobPrompt) {
+    return [
+        "你正在执行一个静默定时任务(后台运行,频道里没有人在等你回复)。",
+        `- 执行这条定时指令: ${jobPrompt}`,
+        "- 默认不要发送频道消息,不要发接手回执,不要创建 task,也不要读频道历史(除非指令要求)。",
+        `- 只有发现异常、需要人处理、或指令明确要求汇报时,才用 \`crew message send --channel ${channelId} --send-draft --content "..."\` 输出到频道。`,
+        "- 只有存在需要后续跟进的具体事项时,才用 `crew task create` 创建任务。",
+        "- 无异常时直接结束,不需要任何输出。",
+    ].join("\n");
+}
 /**
  * 唤醒提示词(OpenSlock 自有设计)。默认"只读补课"模式:先把频道读一遍补齐上下文,
  * 只有发现确实指向自己的事才转为主动处理,否则读完即停、不发声。

package/dist/provider-env.js

@@ -0,0 +1,66 @@
+/**
+ * Custom provider(BYOC)环境注入 —— 与机器全局 Claude 配置互不干扰的关键。纯函数,零 IO。
+ *
+ * 隔离语义(双向):
+ * - agent → 全局:只改子进程 env,绝不写机器全局 ~/.claude / keychain;
+ * - 全局 → agent:custom 时剔除继承自 daemon 启动 shell 的 ANTHROPIC_* 与 Bedrock 等
+ *   路由变量(否则全局中转的 AUTH_TOKEN 会和注入的 key 两套鉴权头一起发、Bedrock 模式
+ *   会整个绕过 baseUrl);有 key 时再把 CLAUDE_CONFIG_DIR 指到 agent 自己的 home,
+ *   该进程完全不读全局 OAuth 登录态(否则已登录订阅账号优先于注入的 key)。
+ */
+import { join } from "node:path";
+/** custom 模式下必须从继承 env 中剔除的全局路由/凭证变量(避免与注入值叠加或抢优先级)。 */
+const CONFLICTING_ENV = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    // 别名钉扎(sonnet/opus/haiku → 具体官方模型名):全局若配了,会把官方模型名带进自定义中转
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+/** 返回叠加了 provider 隔离的新 env(不改入参);非 claude 运行时或 default 模式原样返回。 */
+export function applyProviderEnv(base, runtime, cfg, homeDir) {
+    if (runtime !== "claude" || cfg.provider !== "custom")
+        return base;
+    const env = { ...base };
+    for (const k of CONFLICTING_ENV)
+        delete env[k];
+    if (cfg.providerBaseUrl)
+        env.ANTHROPIC_BASE_URL = cfg.providerBaseUrl;
+    if (cfg.providerApiKey) {
+        if (cfg.providerAuthMode === "api-key")
+            env.ANTHROPIC_API_KEY = cfg.providerApiKey; // x-api-key,直连官方
+        else
+            env.ANTHROPIC_AUTH_TOKEN = cfg.providerApiKey; // Bearer,多数第三方中转(默认)
+        // 凭证齐备 → 彻底隔离:配置目录固定在 agent home 下,claude 的会话/设置/凭证都落在
+        // 这里,不再读机器全局 ~/.claude。目录跨唤醒稳定,--resume 不受影响。
+        env.CLAUDE_CONFIG_DIR = join(homeDir, ".claude");
+    }
+    if (cfg.providerSmallFastModel) {
+        // 新旧两名都设:ANTHROPIC_SMALL_FAST_MODEL 已废弃更名为 ANTHROPIC_DEFAULT_HAIKU_MODEL
+        // (docs/model-config),旧版 CLI 只认旧名、新版认新名,双设覆盖两侧。
+        env.ANTHROPIC_SMALL_FAST_MODEL = cfg.providerSmallFastModel;
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = cfg.providerSmallFastModel;
+    }
+    return env;
+}
+/**
+ * provider 关键配置指纹:default↔custom、换端点、换鉴权方式、key 有↔无都会改变
+ * CLAUDE_CONFIG_DIR/上游,旧 claude 会话在新配置下不可 --resume(会直接报会话不存在),
+ * 供 pickResumeId 判定冷启动。default 恒为 null;不含 key 明文(换 key 同端点可续)。
+ */
+export function providerFingerprint(runtime, cfg) {
+    if (runtime !== "claude" || cfg.provider !== "custom")
+        return null;
+    return [
+        cfg.providerBaseUrl ?? "",
+        cfg.providerAuthMode ?? "auth-token",
+        cfg.providerApiKey ? "key" : "nokey",
+    ].join("|");
+}

package/dist/runner.js

@@ -6,12 +6,13 @@ import { writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { mintAgentToken } from "./token.js";
 import { prepareWorkspace, rotateAgentSession } from "./workspace.js";
-import { buildSystemPrompt, buildWakePrompt } from "./prompt.js";
+import { buildSystemPrompt, buildWakePrompt, capWorkLogForInject } from "./prompt.js";
 import { spawnClaude } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
-import { spawnKimi } from "./runtimes/kimi.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 { readSession, writeSession, pickResumeId } from "./session.js";
+import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
 import { toConsoleLines } from "./console.js";
 import { dslog } from "./slog.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
@@ -28,6 +29,8 @@ onConsole = () => { }) {
     const cfg = cred.config ?? {};
     const runtime = cfg.runtime ?? config.runtimeBin;
     const currentModel = cfg.model ?? null;
+    // provider 配置指纹:custom 配置变更后旧会话不可 --resume(见 provider-env.ts)
+    const providerFp = providerFingerprint(runtime, cfg);
     // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
     //    先 prepare 拿到 memory/workLog,再 build 系统提示词(注入记忆索引)写入。
     const ws = await prepareWorkspace({
@@ -44,7 +47,13 @@ onConsole = () => { }) {
     const prior = config.resume && supportsNativeResume ? await readSession(ws.runDir) : null;
     // 会话身份唯一来源:workspace 的确定性 uuid(ws.agentSessionId)。HEAD 的 warm-window + 开关
     // 只决定「是否续用」:既有会话(sessionResume)且仍在缓存窗口内 → --resume;否则冷启动。
-    const resuming = supportsNativeResume && ws.sessionResume && pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel) != null;
+    const resuming = supportsNativeResume && ws.sessionResume &&
+        pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel, config.sessionBudgetTokens, config.sessionMaxTurns, providerFp) != null;
+    // 预算轮换判定(仅为留痕/提示区分原因):不带预算参数也会续 → 本次冷启动是预算导致的主动轮换
+    const rotatedForBudget = !resuming && supportsNativeResume && ws.sessionResume &&
+        pickResumeId(prior, Date.now(), config.resumeWarmMs, currentModel, 0, 0, providerFp) != null;
+    // soft 预算:仍在续用但上下文已接近 hard 阈值 → 本轮提醒 agent 把现状蒸馏进 work-log(为轮换做准备)
+    const nearBudget = resuming && isNearBudget(prior, config.sessionSoftTokens);
     // 既有会话但本轮不续用 → 轮换出新 uuid 冷启动(避免 --session-id 撞已存在会话)。
     const rotated = !!(ws.agentSessionId && ws.sessionResume && !resuming);
     const launchSessionId = rotated ? await rotateAgentSession(ws.runDir) : ws.agentSessionId;
@@ -59,8 +68,11 @@ onConsole = () => { }) {
         decision_reason: !supportsNativeResume ? "runtime_no_resume"
             : !config.resume ? "resume_disabled"
                 : !ws.sessionResume ? "first_run"
-                    : resuming ? "warm_resume"
-                        : "warm_window_expired_or_model_changed",
+                    : resuming ? (nearBudget ? "warm_resume_near_budget" : "warm_resume")
+                        : rotatedForBudget ? "rotated_for_budget"
+                            : "warm_window_expired_or_model_changed",
+        prior_context_tokens: prior?.contextTokens ?? null,
+        budget_tokens: config.sessionBudgetTokens,
     });
     const systemPrompt = buildSystemPrompt({
         handle: input.handle,
@@ -68,26 +80,34 @@ onConsole = () => { }) {
         agentId: cred.agentId,
         homeDir: ws.dir,
         productName: config.productName,
+        ...(input.scheduled ? { scheduled: true } : {}),
         // 只注入 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/)"
             : ws.memory,
         // resume 时进度已在对话历史里,省去重喂 work-log(resume 省 token 的主要来源);首轮才注入。
-        ...(resuming ? {} : { workLog: ws.workLog }),
+        // 注入截断(防随文件膨胀):全文仍在盘上,超限时保头尾、提示按需 Read。
+        ...(resuming ? {} : { workLog: capWorkLogForInject(ws.workLog) }),
     });
     await writeFile(ws.systemPromptPath, systemPrompt, "utf8");
     // 3) spawn runtime,注入 PATH(crew wrapper)、凭证 env、以及 agent 运行时配置
-    //    provider=custom → BYOC(ANTHROPIC_BASE_URL/API_KEY);reasoning → 思考预算;model → --model
-    const REASONING_TOKENS = { low: "4000", medium: "10000", high: "31999" };
+    //    provider=custom → BYOC(ANTHROPIC_BASE_URL/API_KEY);model → --model;
+    //    reasoning → 原生思考强度(claude --effort / codex -c model_reasoning_effort= /
+    //    kimi KIMI_MODEL_THINKING_EFFORT env;档位白名单在各 runtime 适配器里,白名单外不传)。
     // resume 时提示 agent 上下文已在,无需从头重读频道(配合不注入 work-log,进一步省 token)。
     const baseWake = input.wake ?? buildWakePrompt(input.channelId);
+    const distillHint = nearBudget
+        ? `\n(注意:本会话上下文已接近预算,稍后将轮换重启。本轮结束前,把当前状态——阶段/关键结论/下一步/卡点/关键文件路径——完整更新到 $CREW_TASK_LOG,下轮将以它为基础继续。)`
+        : "";
     const wakePrompt = resuming
-        ? `(继续之前的会话:频道历史与你的进度已在上下文里,不必从头重读;要新消息用 \`crew message read --channel ${input.channelId}\` 增量拉即可。)\n\n${baseWake}`
-        : baseWake;
-    const childEnv = {
+        ? `(继续之前的会话:频道历史与你的进度已在上下文里,不必从头重读;要新消息用 \`crew message read --channel ${input.channelId}\` 增量拉即可。)${distillHint}\n\n${baseWake}`
+        : rotatedForBudget
+            ? `(上下文已轮换:之前的会话过大已重启。你的 work-log 已注入系统提示词末尾,以它为基础继续;频道/线程历史用 crew 命令按需拉取,不必全量重读。)\n\n${baseWake}`
+            : baseWake;
+    const baseEnv = {
         ...process.env,
         // 用户自定义 env(表单 ENVIRONMENT VARIABLES):先合入,可覆盖继承的 shell 环境;
-        // 但 PATH/CREW_*/XDG_* 及下方由表单生成的值(ANTHROPIC_*/思考预算)在其后合入,始终以系统为准。
+        // 但 PATH/CREW_*/XDG_* 及下方由表单生成的值(ANTHROPIC_*/思考强度)在其后合入,始终以系统为准。
         ...sanitizeEnvVars(cfg.envVars),
         PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
         CREW_SERVER_URL: config.serverUrl,
@@ -106,17 +126,18 @@ onConsole = () => { }) {
         XDG_CACHE_HOME: join(ws.homeDir, ".cache"),
         GH_CONFIG_DIR: join(ws.homeDir, ".config", "gh"),
         CLOUDSDK_CONFIG: join(ws.homeDir, ".config", "gcloud"),
-        // provider custom = BYOC:为该 agent 单独设置 Anthropic 端点/密钥
-        ...(cfg.provider === "custom" && cfg.providerBaseUrl ? { ANTHROPIC_BASE_URL: cfg.providerBaseUrl } : {}),
-        ...(cfg.provider === "custom" && cfg.providerApiKey ? { ANTHROPIC_API_KEY: cfg.providerApiKey } : {}),
-        // reasoning → 思考预算 (claude 读 MAX_THINKING_TOKENS;kimi 读 KIMI_MODEL_THINKING_EFFORT,
-        // 值域 low/medium/high/xhigh/max 与本配置兼容,对其它 runtime 无害)
-        ...(cfg.reasoning && cfg.reasoning !== "default" && REASONING_TOKENS[cfg.reasoning]
-            ? { MAX_THINKING_TOKENS: REASONING_TOKENS[cfg.reasoning], KIMI_MODEL_THINKING_EFFORT: cfg.reasoning }
+        // provider custom(BYOC)端点/密钥注入移至下方 applyProviderEnv(含全局残留清理与配置目录隔离)
+        // reasoning → kimi 无对应 CLI 参数,走 KIMI_MODEL_THINKING_EFFORT env(kimi-code 0.23.0,
+        // 值域 low/medium/high/xhigh/max);claude/codex 改走各自 spawn 原生参数(见下),不再注 env。
+        ...(runtime === "kimi" && cfg.reasoning && KIMI_EFFORT_LEVELS.includes(cfg.reasoning)
+            ? { KIMI_MODEL_THINKING_EFFORT: cfg.reasoning }
             : {}),
         // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
         ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
     };
+    // provider custom = BYOC:剔除全局 ANTHROPIC_*/Bedrock 残留 + 按鉴权方式注入端点与密钥,
+    // 与机器全局 Claude 登录态/配置互不干扰(细节见 provider-env.ts)。
+    const childEnv = applyProviderEnv(baseEnv, runtime, cfg, ws.homeDir);
     const child = runtime === "claude"
         ? spawnClaude({
             bin: runtime,
@@ -125,6 +146,7 @@ onConsole = () => { }) {
             wakePrompt,
             dangerous: config.dangerous,
             ...(currentModel ? { model: currentModel } : {}),
+            ...(cfg.reasoning ? { reasoning: cfg.reasoning } : {}),
             // 一线程一会话(唯一会话机制):首轮/冷启动 --session-id 固定 uuid,warm 续轮 --resume 续上。
             ...(launchSessionId ? { sessionId: launchSessionId, resume: resuming } : {}),
             env: childEnv,
@@ -136,6 +158,7 @@ onConsole = () => { }) {
                 wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
                 dangerous: config.dangerous,
                 ...(currentModel ? { model: currentModel } : {}),
+                ...(cfg.reasoning ? { reasoning: cfg.reasoning } : {}),
                 env: childEnv,
             })
             : runtime === "kimi"
@@ -196,19 +219,24 @@ onConsole = () => { }) {
         for (const c of toConsoleLines(evt))
             onConsole(c);
     });
-    child.stderr.on("data", (d) => process.stderr.write(d));
-    const exitCode = await new Promise((resolve) => {
-        child.on("close", (code) => resolve(code ?? 0));
+    // stderr 除透传本地终端外,再留一段尾部:runtime 启动即崩(如 codex 拒跑)时,
+    // 这是唯一的错误线索,要随 error 活动上送,否则失败对 server/web 完全不可见。
+    let stderrTail = "";
+    child.stderr.on("data", (d) => {
+        process.stderr.write(d);
+        stderrTail = (stderrTail + String(d)).slice(-STDERR_TAIL_CAP);
     });
-    // kimi 的 stream-json 没有轮次结束事件(进程退出即结束),补一个 done/error 活动对齐前端状态。
-    if (runtime === "kimi") {
-        const a = exitCode === 0
-            ? { kind: "done", label: "本轮结束" }
-            : { kind: "error", label: "运行出错", detail: `kimi exited with code ${exitCode}` };
-        activities.push(a);
-        onActivity(a);
+    const { exitCode, spawnError } = await awaitExit(child);
+    // spawn 本身失败(如 PATH 里没有 runtime 二进制)没有 stderr,把错误并入尾部供上报。
+    const errorTail = [stderrTail.trim(), spawnError].filter(Boolean).join(" ").trim();
+    const finish = exitActivity(runtime, exitCode, errorTail);
+    if (finish) {
+        activities.push(finish);
+        onActivity(finish);
+        if (finish.kind === "error")
+            onConsole({ stream: "error", text: `✖ ${finish.detail ?? finish.label}` });
     }
-    if ((runtime === "codex" || runtime === "kimi") && exitCode === 0 && !sentViaCrew && finalText) {
+    if (!input.suppressFallback && (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, {
@@ -230,20 +258,65 @@ onConsole = () => { }) {
     }
     // 5) 落盘 session(下次同任务可 --resume),并打印本轮 token 用量(度量 resume 真省与否)
     if (config.resume && supportsNativeResume && sessionId) {
+        // turns 只在续用时累加,轮换/新会话从 1 重计(否则 maxTurns 兜底会让之后每轮都轮换)。
+        // contextTokens = 本轮实测上下文体量;本轮无 usage 时续用轮保留上轮值(会话仍在),新会话清零。
+        const contextTokens = usage
+            ? usage.inputTokens + usage.cacheReadTokens + usage.cacheCreationTokens
+            : (resuming ? prior?.contextTokens : undefined);
         await writeSession(ws.runDir, {
             sessionId,
             lastRunAt: Date.now(),
-            turns: (prior?.turns ?? 0) + 1,
+            turns: resuming ? (prior?.turns ?? 0) + 1 : 1,
             model: currentModel,
+            providerFingerprint: providerFp,
+            ...(contextTokens != null ? { contextTokens } : {}),
         });
     }
     if (usage) {
         const u = usage;
         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)" : "(fresh)"}\n`);
+            `${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 } : {}) };
 }
+/** 随 error 活动上送的 stderr 尾部上限。 */
+const STDERR_TAIL_CAP = 2000;
+/**
+ * 等待子进程结束。必须监听 error:spawn 失败(如 PATH 里没有该 runtime 的二进制)时
+ * Node 只发 error 不发 close——不监听会以未处理异常炸掉整个 daemon 进程,
+ * 且 close 永不触发导致本轮永久挂起。取先到的事件为准。
+ */
+export function awaitExit(child) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (r) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(r);
+        };
+        child.on("error", (e) => settle({ exitCode: -1, spawnError: e.message }));
+        child.on("close", (code) => settle({ exitCode: code ?? 0 }));
+    });
+}
+/**
+ * 进程退出 → 收尾活动。codex/kimi 非零退出必须显式报 error(它们失败时往往一条事件都没吐,
+ * 不报就会被 serve 的「本轮结束」伪装成成功);exitCode -1 是 awaitExit 的 spawn 失败哨兵,
+ * 任何 runtime 都报(spawn 失败连事件流都没有);kimi 正常退出补 done(其 stream 无轮次结束事件);
+ * codex 正常退出与 claude 均返回 null(终态由 turn.completed / result 事件负责)。
+ */
+export function exitActivity(runtime, exitCode, stderrTail) {
+    if ((runtime === "codex" || runtime === "kimi" || exitCode === -1) && exitCode !== 0) {
+        return {
+            kind: "error",
+            label: "运行出错",
+            detail: `${runtime} exited with code ${exitCode}${stderrTail ? `: ${stderrTail}` : ""}`,
+        };
+    }
+    if (runtime === "kimi" && exitCode === 0)
+        return { kind: "done", label: "本轮结束" };
+    return null;
+}
 function defaultPrint(a) {
     const icon = ICON[a.kind] ?? "·";
     const detail = a.detail ? `  ${a.detail.replace(/\s+/g, " ").slice(0, 120)}` : "";

package/dist/runtimes/claude.js

@@ -1,7 +1,11 @@
 /**
  * Claude Code runtime 适配:print + stream-json 模式,headless 驱动。
  */
-import { spawn } from "node:child_process";
+// cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
+import spawn from "cross-spawn";
+// Claude Code 原生 --effort 档位(claude 2.1.196 实测:--help 与非法值告警均枚举这五档)。
+// 白名单外的值(含 "default" 与 codex 专属档)不传参 → 用 claude 自身默认,脏数据不影响启动。
+export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 export function buildClaudeArgs(input) {
     const args = [
         "--print",
@@ -13,6 +17,9 @@ export function buildClaudeArgs(input) {
     ];
     if (input.model)
         args.push("--model", input.model);
+    if (input.reasoning && CLAUDE_EFFORT_LEVELS.includes(input.reasoning)) {
+        args.push("--effort", input.reasoning);
+    }
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }
@@ -22,6 +29,7 @@ export function buildClaudeArgs(input) {
     return args;
 }
 export function spawnClaude(input) {
+    // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
     return spawn(input.bin, buildClaudeArgs(input), {
         cwd: input.cwd,
         env: input.env,

package/dist/runtimes/codex.js

@@ -1,17 +1,28 @@
 /**
  * Codex CLI runtime adapter: non-interactive exec mode with JSONL output.
  */
-import { spawn } from "node:child_process";
+// cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
+import spawn from "cross-spawn";
+// Codex CLI 原生 model_reasoning_effort 档位(codex 0.135.0 实测:非法值时 config 解析报错枚举这六档)。
+// 注意:codex 对非法值是硬失败(进程直接退出),所以必须白名单过滤;白名单外(含 "default"、
+// claude 专属的 "max")不传 → 用 codex 自身默认。
+export const CODEX_EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh"];
 export function buildCodexArgs(input) {
-    const args = ["exec", "--json"];
+    // agent 运行目录由 daemon 管理,不是 git 仓库;不带 --skip-git-repo-check 时 codex exec
+    // 会以 "Not inside a trusted directory" 秒退(且只报在本地 stderr),表现为 agent 静默不回复。
+    const args = ["exec", "--json", "--skip-git-repo-check"];
     if (input.model)
         args.push("--model", input.model);
+    if (input.reasoning && CODEX_EFFORT_LEVELS.includes(input.reasoning)) {
+        args.push("-c", `model_reasoning_effort=${input.reasoning}`);
+    }
     if (input.dangerous)
         args.push("--dangerously-bypass-approvals-and-sandbox");
     args.push(input.wakePrompt);
     return args;
 }
 export function spawnCodex(input) {
+    // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
     return spawn(input.bin, buildCodexArgs(input), {
         cwd: input.cwd,
         env: input.env,

package/dist/runtimes/kimi.js

@@ -8,7 +8,11 @@
  * - 无 system prompt 注入参数 → 与 codex 同法:systemPrompt 拼在 wakePrompt 前。
  * - 鉴权是机器级的(`kimi login` 或 ~/.kimi-code/config.toml),不读 shell 环境变量。
  */
-import { spawn } from "node:child_process";
+// cross-spawn:win32 上 npm CLI 是 .cmd shim,node 原生 spawn 不带 shell 无法执行(ENOENT/EINVAL)
+import spawn from "cross-spawn";
+// Kimi Code 思考强度档位(kimi-code 0.23.0 实测+源码):无 CLI 参数,
+// 由 runner 经 KIMI_MODEL_THINKING_EFFORT env 注入;白名单外的值不注。
+export const KIMI_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 export function buildKimiArgs(input) {
     const args = ["--output-format", "stream-json"];
     if (input.model)
@@ -17,6 +21,7 @@ export function buildKimiArgs(input) {
     return args;
 }
 export function spawnKimi(input) {
+    // stdio 固定 ignore/pipe/pipe,stdout/stderr 必为 Readable;cross-spawn 类型不带该细化,断言之
     return spawn(input.bin, buildKimiArgs(input), {
         cwd: input.cwd,
         env: input.env,

package/dist/serve.js

@@ -7,6 +7,7 @@ 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 { buildScheduledPrompt } from "./prompt.js";
 import { collectMachineHello } from "./machine-info.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
@@ -89,7 +90,7 @@ export function serve(config, opts = {}) {
             // 控制面鉴权拒绝:server 端 resolveToken 未命中有效的 machine 凭证(失效/被吊销/
             // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
             // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
-            // 需在 NowCrew 重新 Add Computer 拿新连接命令)。
+            // 需在 NowWork 重新 Add Computer 拿新连接命令)。
             if (msg.type === "ready") {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
@@ -99,7 +100,7 @@ export function serve(config, opts = {}) {
             if (msg.type === "error") {
                 if (msg.code === "UNAUTHENTICATED") {
                     log(`🛑 控制面拒绝鉴权:机器凭证无效或已吊销 (UNAUTHENTICATED)。`);
-                    log(`   请在 NowCrew 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
+                    log(`   请在 NowWork 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
                     dslog("daemon.ws_auth_rejected", "控制面拒绝鉴权:机器凭证无效或已吊销", { level: "ERROR" });
                     backoff = maxBackoff; // 退避到最大,停止每秒重连刷屏
                 }
@@ -152,9 +153,11 @@ export function serve(config, opts = {}) {
             }
             if (msg.type !== "agent:start")
                 return; // ready/error 等忽略
-            // 任务键 = 线程锚点(≈任务)优先,否则频道。同一 agent 的不同任务可并行;同一任务重复唤醒才跳过。
+            // 任务键: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 threadId = msg.wake?.threadId;
-            const taskKey = threadId ?? msg.channelId;
+            const taskKey = scheduled ? scheduled.runId : (threadId ?? msg.channelId);
             const key = `${msg.agentHandle}:${taskKey}`;
             // run_id 贯穿本轮全链路(wake→start→resume 决策→end),SLS 按 run_id 一查即得单轮时间线
             const runId = randomUUID();
@@ -253,14 +256,20 @@ export function serve(config, opts = {}) {
                 const readCmd = threadId
                     ? `crew thread read`
                     : `crew message read --channel ${msg.channelId}`;
+                const wakeText = scheduled
+                    ? buildScheduledPrompt(msg.channelId, msg.wake?.content ?? "")
+                    : (msg.wake?.content
+                        ? `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}`
+                        : undefined);
                 const result = await runAgent(config, {
                     handle: msg.agentHandle,
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
                     runId, // 贯穿 SLS 日志的单轮关联键
+                    ...(scheduled ? { suppressFallback: true, scheduled: true } : {}),
                     // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
-                    ...(threadId ? { wakeMessageId: threadId } : {}),
-                    ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
+                    ...(!scheduled && threadId ? { wakeMessageId: threadId } : {}),
+                    ...(wakeText ? { wake: wakeText } : {}),
                 }, reportActivity, reportConsole);
                 // 本轮 token 用量上报:runner 已从 result 事件提取(含缓存读/写细分),
                 // 连同模型/runtime 一起上送控制面落库 → 支撑每 agent / 每任务(线程)的用量监控与成本核算。
@@ -284,6 +293,23 @@ export function serve(config, opts = {}) {
                     }
                     catch { /* ws 非 OPEN,忽略(用量非关键路径,丢一轮不阻塞) */ }
                 }
+                // 静默定时 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 会按超时回收 */ }
+                }
                 // run.end 是排查「任务没跑完就本轮结束」的核心证据:退出码 + 时长 + 最后活动 +
                 // 是否 resume + 用量。exit_code!=0 或时长异常短都值得追。
                 const lastActivity = result.activities.length
@@ -302,9 +328,20 @@ export function serve(config, opts = {}) {
                         ...(result.usage.costUsd != null ? { cost_usd: result.usage.costUsd } : {}),
                     } : {}),
                 });
-                reportActivity({ kind: "done", label: "本轮结束" });
-                reportConsole({ stream: "result", text: "● 本轮结束" });
-                log(`✅ agent=${msg.agentHandle} 本轮完成`);
+                if (result.exitCode === 0) {
+                    reportActivity({ kind: "done", label: "本轮结束" });
+                    reportConsole({ stream: "result", text: "● 本轮结束" });
+                    log(`✅ agent=${msg.agentHandle} 本轮完成`);
+                }
+                else {
+                    // 非零退出不能谎报「本轮结束」。runner 已对 codex/kimi 上报带 stderr 的 error 活动,
+                    // 这里只兜底(如 claude 崩溃)并让终态落在 error 上。
+                    if (!result.activities.some((a) => a.kind === "error")) {
+                        reportActivity({ kind: "error", label: "运行出错", detail: `${result.runtime} 退出码 ${result.exitCode}` });
+                    }
+                    reportConsole({ stream: "error", text: `✖ 运行出错 (exit ${result.exitCode})` });
+                    log(`❌ agent=${msg.agentHandle} 本轮失败 (exit ${result.exitCode})`);
+                }
             }
             catch (e) {
                 log(`❌ runAgent 失败: ${e.message}`);
@@ -312,6 +349,19 @@ export function serve(config, opts = {}) {
                     level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
                     error_message: e.message, error_stack: e.stack,
                 });
+                if (scheduled) {
+                    try {
+                        ws?.send(JSON.stringify({
+                            type: "agent:run-complete",
+                            agentHandle: msg.agentHandle,
+                            channelId: msg.channelId,
+                            scheduledRunId: scheduled.runId,
+                            exitCode: -1,
+                            errorMessage: e.message,
+                        }));
+                    }
+                    catch { /* ws 非 OPEN;reaper 兜底 */ }
+                }
             }
             finally {
                 running.delete(key);
@@ -327,7 +377,7 @@ export function serve(config, opts = {}) {
             if (code === 4001) {
                 backoff = maxBackoff;
                 log(`🛑 控制面以鉴权失败关闭连接 (code 4001):机器凭证无效或已吊销。`);
-                log(`   请在 NowCrew 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
+                log(`   请在 NowWork 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
             }
             log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
             // 此刻 server 大概率不可达 → 这条会落 spool,重连 drainSpool 时补传;

package/dist/session.js

@@ -28,6 +28,8 @@ export async function readSession(runDir) {
             lastRunAt: typeof o.lastRunAt === "number" ? o.lastRunAt : 0,
             turns: typeof o.turns === "number" ? o.turns : 0,
             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 } : {}),
         };
     }
     catch {
@@ -43,13 +45,33 @@ export async function writeSession(runDir, meta) {
  * 防负优化:claude 的 prompt cache 有寿命(默认到 1h),间隔超过 warmMs 后 resume 必然
  * cache miss——既读不到旧缓存、又要把更大的历史重写进新缓存,反而比冷启动+work-log 更贵。
  * 故只在缓存窗口内 resume(省),过期则回退冷启动(不亏)。warmMs<=0 关闭阈值(永远 resume)。
+ *
+ * 预算轮换(防上下文无限膨胀):持续活跃的任务会永远命中 warm window,session 历史单调增长
+ * 直到撞模型上限触发被动压缩(慢/贵/质量不可控)。故上轮实测上下文体量(contextTokens)达到
+ * budgetTokens、或续轮数达到 maxTurns(usage 缺失时的兜底)时主动轮换:冷启动 + 注入 work-log
+ * (agent 自己写的结构化现状,比通用摘要保真)。两阈值 <=0 时各自关闭。
  */
-export function pickResumeId(prior, now, warmMs, currentModel = null) {
+export function pickResumeId(prior, now, warmMs, currentModel = null, budgetTokens = 0, maxTurns = 0, currentProviderFingerprint = null) {
     if (!prior)
         return null;
     if (prior.model !== currentModel)
         return null;
+    // provider 配置变了(default↔custom/换端点/换鉴权):旧会话可能存在别的 CLAUDE_CONFIG_DIR
+    // 下,--resume 会直接报错,必须冷启动。
+    if ((prior.providerFingerprint ?? null) !== currentProviderFingerprint)
+        return null;
     if (warmMs > 0 && now - prior.lastRunAt > warmMs)
         return null;
+    if (budgetTokens > 0 && (prior.contextTokens ?? 0) >= budgetTokens)
+        return null;
+    if (maxTurns > 0 && prior.turns >= maxTurns)
+        return null;
     return prior.sessionId;
 }
+/** 上轮上下文是否已接近预算(soft 阈值):是则本轮 wake 附加"蒸馏到 work-log"指令,
+ *  让 agent 在下轮轮换前把现状写全——主动蒸馏替代被动压缩。softTokens<=0 关闭。纯函数。 */
+export function isNearBudget(prior, softTokens) {
+    if (!prior || softTokens <= 0)
+        return false;
+    return (prior.contextTokens ?? 0) >= softTokens;
+}

package/dist/workspace.js

@@ -41,6 +41,8 @@ export async function prepareWorkspace(input) {
     const wrapper = join(crewDir, "crew");
     await writeFile(wrapper, `#!/bin/sh\nexec node ${JSON.stringify(input.cliPath)} "$@"\n`, "utf8");
     await chmod(wrapper, 0o755);
+    // win32 侧 wrapper:cmd/PowerShell 不认 shebang 脚本,并存 crew.cmd(unix 下无害不会被命中)
+    await writeFile(join(crewDir, "crew.cmd"), `@echo off\r\nnode ${JSON.stringify(input.cliPath)} %*\r\n`, "utf8");
     // 每个 agent 独立的 XDG 配置根:隔离第三方 CLI 凭证,避免 agent 之间互相串号
     const homeDir = join(dir, ".home");
     await mkdir(join(homeDir, ".config"), { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.4.4",
+  "version": "0.5.6",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -17,10 +17,12 @@
     "access": "public"
   },
   "dependencies": {
+    "cross-spawn": "^7.0.6",
     "ws": "^8",
-    "@nowcrew/cli": "^0.3.1"
+    "@nowcrew/cli": "^0.4.1"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.0.0",
     "@types/ws": "^8",
     "tsx": "^4.19.0",