@nowcrew/daemon 0.1.2 → 0.3.0

package/dist/config.js

@@ -3,6 +3,7 @@ import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
+import { detectDaemonLang, translateDaemon } from "./i18n.js";
 export class ConfigError extends Error {
 }
 function defaultCliPath() {
@@ -20,7 +21,8 @@ export function loadConfig(env = process.env) {
     const serverUrl = (env.CREW_SERVER_URL ?? "http://127.0.0.1:3000").replace(/\/+$/, "");
     const machineToken = env.CREW_MACHINE_TOKEN ?? "";
     if (!machineToken) {
-        throw new ConfigError("缺少 CREW_MACHINE_TOKEN (sk_machine_*,由 seed 打印)");
+        const lang = detectDaemonLang(env);
+        throw new ConfigError(translateDaemon(lang, "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)"));
     }
     return {
         serverUrl,
@@ -29,5 +31,8 @@ export function loadConfig(env = process.env) {
         cliPath: env.CREW_CLI_PATH ?? defaultCliPath(),
         runtimeBin: env.CREW_RUNTIME ?? "claude",
         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 ?? "OpenSlock",
     };
 }

package/dist/console.js

@@ -8,10 +8,23 @@
  * 注:本转换器针对 claude 的 stream-json。codex 的 stream 格式不同,后续按 runtime 分派扩展;
  * 前端/server 消费的 ConsoleChunk 形状是 runtime 无关的。
  */
+import { detectDaemonLang, translateDaemon } from "./i18n.js";
 /** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
 export const TOOL_RESULT_CAP = 4000;
 /** 工具输入摘要上限(标题行那一段)。 */
 const TOOL_INPUT_CAP = 160;
+/** kimi 工具 arguments(JSON 字符串)容错解析为对象;失败返回 undefined。 */
+function parseKimiToolArgs(args) {
+    if (!args)
+        return undefined;
+    try {
+        const parsed = JSON.parse(args);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** 把工具输入压成一行摘要:Bash 取 command,其它取首个字符串字段或紧凑 JSON。 */
 function summarizeToolInput(name, input) {
     if (!input)
@@ -43,11 +56,22 @@ function clip(s, cap) {
 /** 把一个 stream-json 事件转成 0..N 条 console 行(完全透传)。 */
 export function toConsoleLines(event) {
     const e = (event ?? {});
+    const lang = detectDaemonLang();
+    const td = (message) => translateDaemon(lang, message);
     if (e.type === "system" && e.subtype === "init") {
-        return [{ stream: "system", text: "● claude 会话启动" }];
+        return [{ stream: "system", text: `● ${td("Claude session started")}` }];
+    }
+    if (e.type === "thread.started") {
+        return [{ stream: "system", text: "● codex 会话启动" }];
+    }
+    if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
+        return [{ stream: "text", text: e.item.text.trim() }];
+    }
+    if (e.type === "turn.completed") {
+        return [{ stream: "result", text: "本轮结束" }];
     }
     if (e.type === "result") {
-        const text = e.result?.trim() || (e.is_error ? "运行出错" : "本轮结束");
+        const text = e.result?.trim() || (e.is_error ? td("Run failed") : td("Run finished"));
         return [{ stream: e.is_error ? "error" : "result", text }];
     }
     if (e.type === "assistant" && Array.isArray(e.message?.content)) {
@@ -76,5 +100,21 @@ export function toConsoleLines(event) {
         }
         return out;
     }
+    // kimi stream-json:assistant(正文 + tool_calls)与 tool 结果透传;meta 行(resume hint)不上屏。
+    if (e.role === "assistant" && !e.type) {
+        const out = [];
+        if (typeof e.content === "string" && e.content.trim()) {
+            out.push({ stream: "text", text: e.content.trim() });
+        }
+        for (const call of Array.isArray(e.tool_calls) ? e.tool_calls : []) {
+            const name = call.function?.name;
+            if (name)
+                out.push({ stream: "tool", text: summarizeToolInput(name, parseKimiToolArgs(call.function?.arguments)) });
+        }
+        return out;
+    }
+    if (e.role === "tool" && !e.type && typeof e.content === "string" && e.content.trim()) {
+        return [{ stream: "tool_result", text: clip(e.content.trim(), TOOL_RESULT_CAP) }];
+    }
     return [];
 }

package/dist/i18n.js

@@ -0,0 +1,37 @@
+const normalizeLang = (value) => {
+    if (!value)
+        return null;
+    const lowered = value.toLowerCase();
+    if (lowered.startsWith("zh"))
+        return "zh";
+    if (lowered.startsWith("en"))
+        return "en";
+    return null;
+};
+export function detectDaemonLang(env = process.env) {
+    return normalizeLang(env.CREW_LANG)
+        ?? normalizeLang(env.LC_ALL)
+        ?? normalizeLang(env.LC_MESSAGES)
+        ?? normalizeLang(env.LANG)
+        ?? "en";
+}
+const zh = {
+    "Claude session started": "Claude 会话启动",
+    "Run failed": "运行出错",
+    "Run finished": "本轮结束",
+    "Missing CREW_MACHINE_TOKEN (sk_machine_*, printed by seed)": "缺少 CREW_MACHINE_TOKEN（sk_machine_*，由 seed 打印）",
+    "Usage:": "用法：",
+    "connect and stay resident": "连接并常驻",
+    "run once manually": "手动运行一次",
+    "crew-daemon resident, connecting to": "crew-daemon 常驻，连接到",
+    "control plane": "控制面",
+    "Waking agent": "唤醒 agent",
+    "for channel": "处理频道",
+    "agent exited": "agent 退出",
+    "activities": "活动数",
+};
+export function translateDaemon(lang, message) {
+    if (lang === "zh")
+        return zh[message] ?? message;
+    return message;
+}

package/dist/list-models.js

@@ -0,0 +1,53 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileP = promisify(execFile);
+export async function listRuntimeModels(runtime) {
+    switch (runtime) {
+        case "codex":
+            return parseCodexModels((await execFileP("codex", ["debug", "models"])).stdout);
+        case "cursor":
+            return parseCursorModels((await execFileP("cursor-agent", ["--list-models"])).stdout);
+        case "opencode":
+            return parseOpencodeModels((await execFileP("opencode", ["models"])).stdout);
+        case "pi":
+            return parsePiModels((await execFileP("pi", ["--list-models"])).stdout);
+        default:
+            return null;
+    }
+}
+function parseCodexModels(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        const rows = Array.isArray(parsed.models) ? parsed.models : [];
+        return rows
+            .filter((m) => typeof m.id === "string" && (m.visibility == null || m.visibility === "list"))
+            .map((m, index) => ({ id: m.id, label: m.name || m.id, ...((m.default || index === 0) ? { default: true } : {}) }));
+    }
+    catch {
+        return [];
+    }
+}
+function parseCursorModels(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.includes(" - "))
+        .map((line, index) => {
+        const [id, label] = line.split(/\s+-\s+/, 2);
+        return { id: id.trim(), label: (label || id).trim(), ...(index === 0 ? { default: true } : {}) };
+    });
+}
+function parseOpencodeModels(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("warning:"))
+        .map((line, index) => ({ id: line, label: line, ...(index === 0 ? { default: true } : {}) }));
+}
+function parsePiModels(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.toLowerCase().startsWith("warning"))
+        .map((line, index) => ({ id: line, label: line, ...(index === 0 ? { default: true } : {}) }));
+}

package/dist/machine-info.js

@@ -6,6 +6,7 @@ import { hostname, arch, platform } from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { readFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { dirname, resolve } from "node:path";
 const execFileP = promisify(execFile);
@@ -44,12 +45,30 @@ function daemonVersion() {
         return "0.0.0";
     }
 }
-export async function collectMachineHello() {
+/** 列出 agentsRoot 下的 agent handle(每个子目录 = 一个 agent),跳过隐藏目录;读不到则返回 []。 */
+async function listAgentHandles(agentsRoot) {
+    try {
+        const entries = await readdir(agentsRoot, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name.trim().toLowerCase())
+            .filter((h) => h.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export async function collectMachineHello(agentsRoot) {
+    const [runtimes, agentHandles] = await Promise.all([
+        detectRuntimes(),
+        listAgentHandles(agentsRoot),
+    ]);
     return {
         type: "machine:hello",
         hostname: hostname(),
         os: `${platform()} ${arch()}`,
         daemonVersion: daemonVersion(),
-        runtimes: await detectRuntimes(),
+        runtimes,
+        agentHandles,
     };
 }

package/dist/main.js

@@ -7,9 +7,12 @@
  */
 import { parseArgs } from "node:util";
 import { loadConfig, ConfigError } from "./config.js";
+import { detectDaemonLang, translateDaemon } from "./i18n.js";
 import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
 async function main() {
+    const lang = detectDaemonLang();
+    const td = (message) => translateDaemon(lang, message);
     const { values, positionals } = parseArgs({
         args: process.argv.slice(2),
         allowPositionals: true,
@@ -27,7 +30,9 @@ async function main() {
     // 无子命令时默认 serve(对齐 `npx @nowcrew/daemon@latest --server-url ... --api-key ...`)
     const cmd = positionals[0] ?? "serve";
     if (cmd !== "run" && cmd !== "serve") {
-        process.stderr.write("用法:\n  npx @nowcrew/daemon@latest --server-url <url> --api-key <sk_machine_*>   # 连接并常驻\n  crew-daemon run --agent <h> --channel <id> [--wake ...]                  # 手动跑一次\n");
+        process.stderr.write(td("Usage:") + "\n" +
+            "  npx @nowcrew/daemon@latest --server-url <url> --api-key <sk_machine_*>   # " + td("connect and stay resident") + "\n" +
+            "  crew-daemon run --agent <h> --channel <id> [--wake ...]                  # " + td("run once manually") + "\n");
         process.exit(2);
     }
     // 命令行参数优先于环境变量,填回 env 供 loadConfig 读取
@@ -48,23 +53,23 @@ async function main() {
         throw e;
     }
     if (cmd === "serve") {
-        process.stdout.write(`\n🛰️  crew-daemon 常驻,连接 ${config.serverUrl} 控制面...\n`);
+        process.stdout.write(`\n🛰️  ${td("crew-daemon resident, connecting to")} ${config.serverUrl} ${td("control plane")}...\n`);
         serve(config);
         await new Promise(() => { }); // 常驻,直到被 kill
         return;
     }
     if (!values.agent || !values.channel) {
-        process.stderr.write("用法: crew-daemon run --agent <handle> --channel <id> [--wake ...]\n");
+        process.stderr.write(`${td("Usage:")} crew-daemon run --agent <handle> --channel <id> [--wake ...]\n`);
         process.exit(2);
     }
-    process.stdout.write(`\n🚀 唤醒 agent "${values.agent}" 处理频道 ${values.channel}\n\n`);
+    process.stdout.write(`\n🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}\n\n`);
     const result = await runAgent(config, {
         handle: values.agent,
         channelId: values.channel,
         ...(values.wake ? { wake: values.wake } : {}),
         ...(values.display ? { displayName: values.display } : {}),
     });
-    process.stdout.write(`\n— agent 退出 (code ${result.exitCode}),共 ${result.activities.length} 个活动 —\n`);
+    process.stdout.write(`\n— ${td("agent exited")} (code ${result.exitCode}), ${td("activities")}: ${result.activities.length} —\n`);
     process.exit(result.exitCode);
 }
 main().catch((e) => {

package/dist/normalize.js

@@ -19,12 +19,38 @@ export function classifyCommand(command) {
         return { kind: "crew", label: "crew 命令", detail: c };
     return { kind: "tool", label: "执行命令", detail: c };
 }
+/** kimi 的 Bash 工具 arguments 是 JSON 字符串({"command": "..."}),容错解析出 command。 */
+function parseKimiBashCommand(args) {
+    if (!args)
+        return null;
+    try {
+        const parsed = JSON.parse(args);
+        return typeof parsed.command === "string" && parsed.command.trim() ? parsed.command.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** 把一个 stream-json 事件归一化为 0..N 个活动。 */
 export function normalizeEvent(event) {
     const e = (event ?? {});
     if (e.type === "system" && e.subtype === "init") {
         return [{ kind: "init", label: "agent 启动" }];
     }
+    if (e.type === "thread.started") {
+        return [{ kind: "init", label: "agent 启动" }];
+    }
+    if (e.type === "item.completed" && e.item?.type === "agent_message" && e.item.text?.trim()) {
+        return [{ kind: "text", label: "思考/说明", detail: e.item.text.trim() }];
+    }
+    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)];
+    }
+    if (e.type === "turn.completed") {
+        return [{ kind: "done", label: "本轮结束" }];
+    }
     if (e.type === "result") {
         return e.is_error
             ? [{ kind: "error", label: "运行出错", ...(e.result ? { detail: e.result } : {}) }]
@@ -50,8 +76,48 @@ export function normalizeEvent(event) {
         if (hasResult)
             return [{ kind: "tool_result", label: "工具返回" }];
     }
+    // kimi stream-json:{role:"assistant", content?, tool_calls?} / {role:"tool", ...}。
+    // kimi 行没有顶层 type(meta 行 role="meta",不产活动),与 claude/codex 分支互斥。
+    if (e.role === "assistant" && !e.type) {
+        const out = [];
+        if (typeof e.content === "string" && e.content.trim()) {
+            out.push({ kind: "text", label: "思考/说明", detail: e.content.trim() });
+        }
+        for (const call of Array.isArray(e.tool_calls) ? e.tool_calls : []) {
+            const name = call.function?.name ?? "";
+            const command = name === "Bash" ? parseKimiBashCommand(call.function?.arguments) : null;
+            if (command)
+                out.push(classifyCommand(command));
+            else if (name)
+                out.push({ kind: "tool", label: `工具:${name}` });
+        }
+        return out;
+    }
+    if (e.role === "tool" && !e.type) {
+        return [{ kind: "tool_result", label: "工具返回" }];
+    }
     return [];
 }
+export function extractRunMeta(event) {
+    const e = (event ?? {});
+    const meta = {};
+    // 任何带 session_id 的事件(system/init、result …)都用来确认/更新 session id
+    if (typeof e.session_id === "string" && e.session_id)
+        meta.sessionId = e.session_id;
+    if (typeof e.thread_id === "string" && e.thread_id)
+        meta.sessionId = e.thread_id;
+    // 仅 result 事件携带本轮 usage 汇总
+    if ((e.type === "result" || e.type === "turn.completed") && e.usage) {
+        meta.usage = {
+            inputTokens: e.usage.input_tokens ?? 0,
+            outputTokens: e.usage.output_tokens ?? 0,
+            cacheReadTokens: e.usage.cache_read_input_tokens ?? e.usage.cached_input_tokens ?? 0,
+            cacheCreationTokens: e.usage.cache_creation_input_tokens ?? 0,
+            ...(typeof e.total_cost_usd === "number" ? { costUsd: e.total_cost_usd } : {}),
+        };
+    }
+    return meta;
+}
 /** 解析一行 ndjson;非法行返回 null。 */
 export function parseLine(line) {
     const t = line.trim();

package/dist/prompt.js

@@ -6,12 +6,13 @@
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
 export function buildSystemPrompt(ctx) {
-    return `你是 "${ctx.handle}",OpenSlock(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。OpenSlock 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
+    const product = ctx.productName ?? "OpenSlock";
+    return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
 你的 workspace 和 MEMORY.md 跨会话保留,被唤醒时可恢复上下文。你会被启动、空闲时休眠、有人给你发消息时再次唤醒。把自己当成一位始终在线、随时间积累知识、通过交互形成专长的同事——而不是一次性聊天机器人。
 
-## 当前运行时上下文(由 OpenSlock 注入,权威)
+## 当前运行时上下文(由 ${product} 注入,权威)
 - Handle: ${ctx.handle}${ctx.agentId ? `\n- Agent ID: ${ctx.agentId}` : ""}
 - 你被唤醒处理的频道: ${ctx.channelId}
 - **你的 cwd 是本任务的隔离工作目录**(代码检出/构建/草稿都放这里;你可能同时有多个并行运行,各自 cwd 独立,互不干扰)。
@@ -35,9 +36,9 @@ export function buildSystemPrompt(ctx) {
    你的消息正文,可含 "引号"、\\\`反引号\\\`、代码块。
    CREWMSG
    \`\`\`
-   也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <msg码>\`(msg 码来自 read/search 输出里的 \`msg=\` 前 8 位)。
+   也可用 \`--content "<短正文>"\`。线程内回复:加 \`--thread <完整线程根消息 id>\`。被唤醒时优先使用环境变量 \`$CREW_WAKE_MESSAGE_ID\` 或唤醒提示里的完整 id,不要手动截短。
 5. **\`crew task list --channel <id>\`** —— 看任务板。支持 \`--status <s>\` / \`--mine\`。
-6. **\`crew task create --channel <id> --title "<标题>"\`** —— 新建任务(把一件事登记成可追踪的工作项)。
+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>\`** —— 释放认领,把任务让给别人。
@@ -64,7 +65,7 @@ CRITICAL 规则:
 - 你读到的消息形如 \`#<seq> [<type>] <sender>: <正文>\`,\`type\` 为 \`human\` / \`agent\` / \`system\`。
 - **\`system\` 消息**通报频道状态变化(如新建任务),除非明确要求你行动(如刚给你指派了任务),否则不要回复。
 - **判定规则**:若满足来信需要你"回复之外的动作"(跑工具/改代码/做变更),先 claim;若只是回答问题或闲聊,无需 claim。
-- **线程 = 工作单元 / 一个请求一个 task(CRITICAL)**:一条对话(thread)对应一件事,最多绑**一个** task。被唤醒处理来信时,对这件事**只建一个 task**:\`crew task create --title "…"\`(不带 --new-thread)会把它绑到**当前线程**(触发你的那条消息所在线程),不另发顶层消息。**别把一个请求拆成多个 task**(如"拉代码"+"读文档"+"写记忆"是同一件事 → 一个 task,用 todo/进度推进,不要建第二个)。当前线程已有 task 时再 \`crew task create\` 会被服务端拒绝(报错会提示你)。
+- **线程 = 工作单元 / 一个请求一个 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)。**严禁把进度发到别的线程或频道顶层。**
 - **毫不相关的新任务才另起线程**:只有要处理的事**和当前线程毫不相关**(或用户明确要求新建)时,才用 \`crew task create --new-thread --title "…"\`——系统另起一个子线程(parent=当前线程)绑新 task;之后这件事的回复要发到**这个新子线程**里。能不拆就不拆。
 - 任务状态流:\`todo → in_progress → in_review → done\`。claim 后用 \`crew task update\` 推进:开工→in_progress、完成待验收→in_review、人类确认后→done。只有 assignee 能改自己任务的状态。
@@ -98,7 +99,7 @@ ${ctx.memory ? `\n## [注入] 你的 MEMORY.md(索引,只读参考)\n${ctx.memor
  * 只有发现确实指向自己的事才转为主动处理,否则读完即停、不发声。
  */
 export function buildWakePrompt(channelId) {
-    return `先补齐上下文:若本轮在某个线程里(被唤醒处理某 thread),用 \`crew thread read\` 读**当前线程 + 它的父线程**(聚焦上下文,最多向上一层);需要更全局再用 \`crew message read --channel ${channelId}\` 读整个频道。
+    return `先补齐上下文:若本轮在某个线程里(被唤醒处理某 thread),用 \`crew thread read\` 读**当前线程 + 它的父线程**(聚焦上下文,最多向上一层);需要更全局再用 \`crew message read --channel ${channelId} --limit 100\` 读最近 100 条(频道消息过多时全量加载会 prompt 爆炸,需要更早的历史用 \`--after <seq>\` 分段拉)。
 读完判断:其中是否有明确落到你头上的事——点名找你、@你、指派给你、请你评审,或交给你的任务。
 - 有:转入主动处理。相关任务先 \`crew task claim <taskId>\` 认领再动手,完成后用 \`crew message send --channel ${channelId}\` 回复。
 - 没有:本轮什么都不要发,读完即停。你存活期间有新消息会自动送来,无需轮询。`;

package/dist/runner.js

@@ -5,10 +5,13 @@ import { createInterface } from "node:readline";
 import { writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 import { mintAgentToken } from "./token.js";
-import { prepareWorkspace } from "./workspace.js";
+import { prepareWorkspace, rotateAgentSession } from "./workspace.js";
 import { buildSystemPrompt, buildWakePrompt } from "./prompt.js";
 import { spawnClaude } from "./runtimes/claude.js";
-import { normalizeEvent, parseLine } from "./normalize.js";
+import { spawnCodex } from "./runtimes/codex.js";
+import { spawnKimi } from "./runtimes/kimi.js";
+import { normalizeEvent, parseLine, extractRunMeta } from "./normalize.js";
+import { readSession, writeSession, pickResumeId } from "./session.js";
 import { toConsoleLines } from "./console.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
 const MEMORY_INJECT_CAP = 6000;
@@ -20,7 +23,10 @@ export async function runAgent(config, input, onActivity = defaultPrint,
 // 终端透传:每条 stream-json 事件除归一化为状态活动外,再产出 console 行供前端终端窗口渲染。
 onConsole = () => { }) {
     // 1) 用机器令牌换 per-launch agent 令牌
-    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName);
+    const cred = await mintAgentToken(config.serverUrl, config.machineToken, input.handle, input.displayName, input.wakeMessageId);
+    const cfg = cred.config ?? {};
+    const runtime = cfg.runtime ?? config.runtimeBin;
+    const currentModel = cfg.model ?? null;
     // 2) 准备 workspace(共享 home + 本任务隔离 cwd + per-task work-log)。
     //    先 prepare 拿到 memory/workLog,再 build 系统提示词(注入记忆索引)写入。
     const ws = await prepareWorkspace({
@@ -31,72 +37,135 @@ onConsole = () => { }) {
         // 仅在首次创建 MEMORY.md 时,用 agent 的 description 种子化 ## Role
         ...(cred.config?.description ? { description: cred.config.description } : {}),
     });
+    // session resume:同任务有历史会话且仍在缓存窗口内 → spawn 时 --resume 复用上下文(省 token)。
+    // 关:CREW_RESUME=off;超 warm 窗口 → 冷启动(避免 cache miss 重写更贵);读取容错(损坏 → 当首轮)。
+    const supportsNativeResume = runtime === "claude";
+    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;
+    // 既有会话但本轮不续用 → 轮换出新 uuid 冷启动(避免 --session-id 撞已存在会话)。
+    const launchSessionId = ws.agentSessionId && ws.sessionResume && !resuming
+        ? await rotateAgentSession(ws.runDir)
+        : ws.agentSessionId;
     const systemPrompt = buildSystemPrompt({
         handle: input.handle,
         channelId: input.channelId,
         agentId: cred.agentId,
         homeDir: ws.dir,
+        productName: config.productName,
         // 只注入 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,
-        workLog: ws.workLog,
+        // resume 时进度已在对话历史里,省去重喂 work-log(resume 省 token 的主要来源);首轮才注入。
+        ...(resuming ? {} : { workLog: 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 cfg = cred.config ?? {};
     const REASONING_TOKENS = { low: "4000", medium: "10000", high: "31999" };
-    const child = spawnClaude({
-        bin: config.runtimeBin,
-        cwd: ws.runDir, // 本任务隔离工作目录(并行运行互不干扰)
-        systemPromptPath: ws.systemPromptPath,
-        wakePrompt: input.wake ?? buildWakePrompt(input.channelId),
-        dangerous: config.dangerous,
-        ...(cfg.model ? { model: cfg.model } : {}),
-        // 一线程一会话:首轮 --session-id 固定 id,之后 --resume 续上(更原生地复用 claude 记忆)
-        ...(ws.agentSessionId ? { sessionId: ws.agentSessionId, resume: ws.sessionResume } : {}),
-        env: {
-            ...process.env,
-            PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
-            CREW_SERVER_URL: config.serverUrl,
-            CREW_TOKEN: cred.token,
-            CREW_CHANNEL: input.channelId,
-            // 共享持久记忆 home(MEMORY.md/notes 在此;cwd 是本任务隔离目录)+ 本任务 work-log 路径
-            CREW_HOME: ws.dir,
-            CREW_TASK_LOG: ws.workLogPath,
-            // 唤醒锚点消息 id:有则 `crew task create` 把任务锚定到这条触发消息(讨论与任务锚点统一),
-            // 而非另发一条标题消息当锚点(那会让点开 task 的 thread 永远为空)。
-            ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
-            // per-agent 凭证隔离:XDG 指向本 agent 独立目录(gh/gcloud 等 CLI 的 token 不互相串)。
-            // 不覆盖 HOME(否则会破坏 claude 自身的 ~/.claude 鉴权);常用 CLI 也单独点名隔离。
-            XDG_CONFIG_HOME: join(ws.homeDir, ".config"),
-            XDG_DATA_HOME: join(ws.homeDir, ".local", "share"),
-            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)
-            ...(cfg.reasoning && cfg.reasoning !== "default" && REASONING_TOKENS[cfg.reasoning]
-                ? { MAX_THINKING_TOKENS: REASONING_TOKENS[cfg.reasoning] }
-                : {}),
-            // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
-            ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
-        },
-    });
-    // 4) 逐行解析 stdout → 归一化 → 回调
+    // resume 时提示 agent 上下文已在,无需从头重读频道(配合不注入 work-log,进一步省 token)。
+    const baseWake = input.wake ?? buildWakePrompt(input.channelId);
+    const wakePrompt = resuming
+        ? `(继续之前的会话:频道历史与你的进度已在上下文里,不必从头重读;要新消息用 \`crew message read --channel ${input.channelId}\` 增量拉即可。)\n\n${baseWake}`
+        : baseWake;
+    const childEnv = {
+        ...process.env,
+        PATH: `${ws.crewDir}${delimiter}${process.env.PATH ?? ""}`,
+        CREW_SERVER_URL: config.serverUrl,
+        CREW_TOKEN: cred.token,
+        CREW_CHANNEL: input.channelId,
+        // 共享持久记忆 home(MEMORY.md/notes 在此;cwd 是本任务隔离目录)+ 本任务 work-log 路径
+        CREW_HOME: ws.dir,
+        CREW_TASK_LOG: ws.workLogPath,
+        // 唤醒锚点消息 id:有则 `crew task create` 把任务锚定到这条触发消息(讨论与任务锚点统一),
+        // 而非另发一条标题消息当锚点(那会让点开 task 的 thread 永远为空)。
+        ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
+        // per-agent 凭证隔离:XDG 指向本 agent 独立目录(gh/gcloud 等 CLI 的 token 不互相串)。
+        // 不覆盖 HOME(否则会破坏 claude 自身的 ~/.claude 鉴权);常用 CLI 也单独点名隔离。
+        XDG_CONFIG_HOME: join(ws.homeDir, ".config"),
+        XDG_DATA_HOME: join(ws.homeDir, ".local", "share"),
+        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 }
+            : {}),
+        // fast 模式 → 透传给 runtime(best-effort,供 wrapper/runtime 读取)
+        ...(cfg.fastMode ? { CREW_FAST_MODE: "1" } : {}),
+    };
+    const child = runtime === "claude"
+        ? spawnClaude({
+            bin: runtime,
+            cwd: ws.runDir, // 本任务隔离工作目录(并行运行互不干扰)
+            systemPromptPath: ws.systemPromptPath,
+            wakePrompt,
+            dangerous: config.dangerous,
+            ...(currentModel ? { model: currentModel } : {}),
+            // 一线程一会话(唯一会话机制):首轮/冷启动 --session-id 固定 uuid,warm 续轮 --resume 续上。
+            ...(launchSessionId ? { sessionId: launchSessionId, resume: resuming } : {}),
+            env: childEnv,
+        })
+        : runtime === "codex"
+            ? spawnCodex({
+                bin: runtime,
+                cwd: ws.runDir,
+                wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
+                dangerous: config.dangerous,
+                ...(currentModel ? { model: currentModel } : {}),
+                env: childEnv,
+            })
+            : runtime === "kimi"
+                ? spawnKimi({
+                    bin: runtime,
+                    cwd: ws.runDir,
+                    // kimi 与 codex 一样没有 system prompt 参数,拼在 wake prompt 前;
+                    // -p 模式固定 auto 权限,dangerous 无对应 flag(见 runtimes/kimi.ts)。
+                    wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
+                    ...(currentModel ? { model: currentModel } : {}),
+                    env: childEnv,
+                })
+                : (() => {
+                    throw new Error(`unsupported runtime: ${runtime}`);
+                })();
+    // 4) 逐行解析 stdout → 归一化 → 回调;顺带抓 session_id(记 lastRunAt 供 warm-window)+ token usage(度量)
     const activities = [];
+    // 身份是本轮下发的 launchSessionId;仍兜底采 claude 自报的 session_id(理应一致)。
+    let sessionId = launchSessionId;
+    let usage;
+    let finalText = null;
+    let sentViaCrew = false;
     const rl = createInterface({ input: child.stdout });
     rl.on("line", (line) => {
         const evt = parseLine(line);
         if (!evt)
             return;
+        const meta = extractRunMeta(evt);
+        if (meta.sessionId)
+            sessionId = meta.sessionId;
+        if (meta.usage)
+            usage = meta.usage;
         for (const a of normalizeEvent(evt)) {
+            if (a.kind === "sending")
+                sentViaCrew = true;
             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();
+        }
         // 同一事件再透传为终端 console 行(独立于状态活动,内容不压缩)。
         for (const c of toConsoleLines(evt))
             onConsole(c);
@@ -105,10 +174,57 @@ onConsole = () => { }) {
     const exitCode = await new Promise((resolve) => {
         child.on("close", (code) => resolve(code ?? 0));
     });
-    return { exitCode, activities };
+    // 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);
+    }
+    if ((runtime === "codex" || runtime === "kimi") && exitCode === 0 && !sentViaCrew && finalText) {
+        const sent = await sendAgentMessage(config.serverUrl, cred.token, input.channelId, {
+            content: finalText,
+            ...(input.wakeMessageId ? { thread: input.wakeMessageId } : {}),
+        });
+        if (sent.ok) {
+            const a = { kind: "sending", label: "发消息", detail: `${runtime} final answer fallback` };
+            activities.push(a);
+            onActivity(a);
+        }
+        else {
+            process.stderr.write(`${runtime} fallback send failed (HTTP ${sent.status})\n`);
+        }
+    }
+    // 5) 落盘 session(下次同任务可 --resume),并打印本轮 token 用量(度量 resume 真省与否)
+    if (config.resume && supportsNativeResume && sessionId) {
+        await writeSession(ws.runDir, {
+            sessionId,
+            lastRunAt: Date.now(),
+            turns: (prior?.turns ?? 0) + 1,
+            model: currentModel,
+        });
+    }
+    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`);
+    }
+    return { exitCode, activities, ...(usage ? { usage } : {}) };
 }
 function defaultPrint(a) {
     const icon = ICON[a.kind] ?? "·";
     const detail = a.detail ? `  ${a.detail.replace(/\s+/g, " ").slice(0, 120)}` : "";
     process.stdout.write(`${icon} ${a.label}${detail}\n`);
 }
+async function sendAgentMessage(serverUrl, token, channelId, body) {
+    const res = await fetch(`${serverUrl}/agent/channels/${encodeURIComponent(channelId)}/messages`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    return { ok: res.ok, status: res.status };
+}

package/dist/runtimes/codex.js

@@ -0,0 +1,20 @@
+/**
+ * Codex CLI runtime adapter: non-interactive exec mode with JSONL output.
+ */
+import { spawn } from "node:child_process";
+export function buildCodexArgs(input) {
+    const args = ["exec", "--json"];
+    if (input.model)
+        args.push("--model", input.model);
+    if (input.dangerous)
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    args.push(input.wakePrompt);
+    return args;
+}
+export function spawnCodex(input) {
+    return spawn(input.bin, buildCodexArgs(input), {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}

package/dist/runtimes/kimi.js

@@ -0,0 +1,25 @@
+/**
+ * Kimi Code CLI runtime adapter: non-interactive prompt mode with stream-json output.
+ *
+ * 事实依据(kimi-code 0.23.0 本机实测 + 官方文档 www.kimi.com/code/docs):
+ * - `kimi -p <prompt> --output-format stream-json`:单次非交互执行,stdout 每行一个 JSON。
+ * - `-p` 固定 auto 权限(自动批准普通工具调用),且与 --yolo/--auto/--plan 互斥,
+ *   故 dangerous 无需(也不能)映射任何 flag。
+ * - 无 system prompt 注入参数 → 与 codex 同法:systemPrompt 拼在 wakePrompt 前。
+ * - 鉴权是机器级的(`kimi login` 或 ~/.kimi-code/config.toml),不读 shell 环境变量。
+ */
+import { spawn } from "node:child_process";
+export function buildKimiArgs(input) {
+    const args = ["--output-format", "stream-json"];
+    if (input.model)
+        args.push("--model", input.model);
+    args.push("--prompt", input.wakePrompt);
+    return args;
+}
+export function spawnKimi(input) {
+    return spawn(input.bin, buildKimiArgs(input), {
+        cwd: input.cwd,
+        env: input.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}

package/dist/serve.js

@@ -9,6 +9,7 @@ import { collectMachineHello } 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";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
@@ -57,11 +58,11 @@ export function serve(config, opts = {}) {
             backoff = 1000;
             log(`🔌 已连接控制面 ${config.serverUrl}`);
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
-            void collectMachineHello()
+            void collectMachineHello(config.agentsRoot)
                 .then((hello) => {
                 try {
                     ws?.send(JSON.stringify(hello));
-                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · runtimes=[${hello.runtimes.join(",")}]`);
+                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · runtimes=[${hello.runtimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
                 }
                 catch { /* 非 OPEN,忽略 */ }
             })
@@ -76,6 +77,18 @@ export function serve(config, opts = {}) {
             catch {
                 return;
             }
+            // 控制面鉴权拒绝:server 端 resolveToken 未命中有效的 machine 凭证(失效/被吊销/
+            // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
+            // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
+            // 需在 NowCrew 重新 Add Computer 拿新连接命令)。
+            if (msg.type === "error") {
+                if (msg.code === "UNAUTHENTICATED") {
+                    log(`🛑 控制面拒绝鉴权:机器凭证无效或已吊销 (UNAUTHENTICATED)。`);
+                    log(`   请在 NowCrew 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
+                    backoff = maxBackoff; // 退避到最大,停止每秒重连刷屏
+                }
+                return;
+            }
             // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
             if (msg.type === "raft:inspect" || msg.type === "raft:import") {
                 const req = msg;
@@ -100,7 +113,7 @@ export function serve(config, opts = {}) {
                 return;
             }
             // workspace 文件浏览 / skills 枚举请求 (只读、沙箱;见 workspace-fs.ts / skills.ts)
-            if (msg.type === "fs:list" || msg.type === "fs:read" || msg.type === "skills:list") {
+            if (msg.type === "fs:list" || msg.type === "fs:read" || msg.type === "skills:list" || msg.type === "probe-models") {
                 const req = msg;
                 const root = join(config.agentsRoot, req.handle);
                 const reply = (r) => {
@@ -112,7 +125,8 @@ export function serve(config, opts = {}) {
                 try {
                     const data2 = req.type === "fs:list" ? await listWorkspace(root, req.path)
                         : req.type === "fs:read" ? await readWorkspaceFile(root, req.path)
-                            : await listSkills(config.agentsRoot, req.handle);
+                            : req.type === "skills:list" ? await listSkills(config.agentsRoot, req.handle)
+                                : { models: await listRuntimeModels(req.type === "probe-models" ? (req.runtime ?? "") : "") };
                     reply({ ok: true, data: data2 });
                 }
                 catch (e) {
@@ -133,13 +147,13 @@ export function serve(config, opts = {}) {
             running.add(key);
             // 并行槽:同 agent 超过 MAX_PARALLEL 个任务时在此排队(不丢),有空位再跑。
             await acquireSlot(msg.agentHandle);
-            const threadCode = threadId ? threadId.slice(0, 8) : null;
+            const threadLabel = threadId ?? null;
             const from = msg.wake?.senderHandle ?? "?";
             const incoming = msg.wake?.content ?? "";
             log(`\n${"─".repeat(56)}`);
             log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
             log(`   channel = ${msg.channelId}`);
-            log(`   thread  = ${threadCode ? `${threadCode} (要求线程内回复)` : "(无,顶层回复)"}`);
+            log(`   thread  = ${threadLabel ? `${threadLabel} (要求线程内回复)` : "(无,顶层回复)"}`);
             if (incoming)
                 log(`📥 来信 @${from}: ${incoming.replace(/\s+/g, " ").slice(0, 200)}`);
             let actSeq = 0;
@@ -149,7 +163,7 @@ export function serve(config, opts = {}) {
                 let line = `  · ${a.label}`;
                 if (a.kind === "sending") {
                     const m = det.match(/--content\s+"([^"]*)"/) || det.match(/<<'?\w+'?\s*(.*)/);
-                    line = `  💬 回复${threadCode ? `(thread ${threadCode})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
+                    line = `  💬 回复${threadLabel ? `(thread ${threadLabel})` : ""}: ${m ? m[1].slice(0, 160) : det.slice(0, 120)}`;
                 }
                 else if (det) {
                     line += ` ${det.slice(0, 80)}`;
@@ -186,8 +200,8 @@ export function serve(config, opts = {}) {
             try {
                 // 线程聚合:触发消息即任务线程根,你的确认+后续所有回复都要发到它的线程里,
                 // 不要发顶层——这样 task 讨论全部聚合在该 thread 下。
-                const threadHint = threadCode
-                    ? `\n**所有回复都必须发到这条消息的线程里**(任务线程):用 crew message send --channel ${msg.channelId} --thread ${threadCode} 发送,不要发频道顶层。`
+                const threadHint = threadId
+                    ? `\n**所有回复都必须发到这条消息的线程里**(任务线程):用 crew message send --channel ${msg.channelId} --thread ${threadId} 发送,不要发频道顶层。`
                     : "";
                 // channel(广播投递):你是频道成员之一,自己判断是否与你职责相关——相关才行动(回复 /
                 // crew task create / claim / 交接给下一棒),不相关就不回(频道沉默不算失败,避免人人都答)。
@@ -197,19 +211,24 @@ export function serve(config, opts = {}) {
                 // 关键协作礼仪:一旦决定接手,**第一步就先在频道发一句简短确认**
                 // (例:"收到,我接 task #N。先做 X / 排查 Y,有结论再同步"),别让频道空着干等;
                 // 然后再开始读日志/跑命令。干完用 @下一棒 或 crew task assign 交接。
-                const sendCmd = threadCode
-                    ? `crew message send --channel ${msg.channelId} --thread ${threadCode}`
+                const sendCmd = threadId
+                    ? `crew message send --channel ${msg.channelId} --thread ${threadId}`
                     : `crew message send --channel ${msg.channelId}`;
                 const ackHint = `\n**协作礼仪:决定接手后,务必先用 \`${sendCmd}\` 在该任务线程发一句简短确认**(收到 + 我接 task #N + 接下来要做什么),再开始干活——不要闷头工作把线程空着。`;
                 // 图片/文件附件:crew message read 会在消息下列出附件及其 id;图片需下载后用 Read 工具查看,才能真正"看到"内容。
                 const attHint = `\n若消息带图片/文件附件(read 会列出 id),用 \`crew attachment get <id>\` 下载到本地,图片再用 Read 工具打开查看后再处理。`;
+                // 线程隔离:有 threadId 时用 `crew thread read` 只读本线程(避免被其他线程消息干扰);
+                // 顶层消息(无 threadId)用 `crew message read` 读整个频道。
+                const readCmd = threadId
+                    ? `crew thread read`
+                    : `crew message read --channel ${msg.channelId}`;
                 await runAgent(config, {
                     handle: msg.agentHandle,
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
                     // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
                     ...(threadId ? { wakeMessageId: threadId } : {}),
-                    ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 crew message read --channel ${msg.channelId} 读频道后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
+                    ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
                 }, reportActivity, reportConsole);
                 reportActivity({ kind: "done", label: "本轮结束" });
                 reportConsole({ stream: "result", text: "● 本轮结束" });
@@ -223,9 +242,16 @@ export function serve(config, opts = {}) {
                 releaseSlot(msg.agentHandle);
             }
         });
-        ws.on("close", () => {
+        ws.on("close", (code) => {
             if (stopped)
                 return;
+            // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
+            // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。
+            if (code === 4001) {
+                backoff = maxBackoff;
+                log(`🛑 控制面以鉴权失败关闭连接 (code 4001):机器凭证无效或已吊销。`);
+                log(`   请在 NowCrew 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
+            }
             log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
             setTimeout(connect, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);

package/dist/session.js

@@ -0,0 +1,55 @@
+/**
+ * per-task claude 会话元数据 —— 让同一任务的重复唤醒用 `--resume` 复用上下文(省 token)。
+ *
+ * 存在本任务隔离运行目录下(<runDir>/.crew-session.json):天然按 taskKey 隔离、落盘防 daemon
+ * 重启丢失。读取一律容错 → 不存在/损坏/字段非法都回退 null(= 当作首轮冷启动),绝不阻断运行。
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const FILE = ".crew-session.json";
+export function sessionPath(runDir) {
+    return join(runDir, FILE);
+}
+/** 读会话元数据;不存在/坏 json/缺 sessionId → null(回退冷启动,绝不抛)。 */
+export async function readSession(runDir) {
+    let raw;
+    try {
+        raw = await readFile(sessionPath(runDir), "utf8");
+    }
+    catch {
+        return null; // 文件不存在 = 首轮
+    }
+    try {
+        const o = JSON.parse(raw);
+        if (typeof o.sessionId !== "string" || !o.sessionId)
+            return null;
+        return {
+            sessionId: o.sessionId,
+            lastRunAt: typeof o.lastRunAt === "number" ? o.lastRunAt : 0,
+            turns: typeof o.turns === "number" ? o.turns : 0,
+            model: typeof o.model === "string" ? o.model : null,
+        };
+    }
+    catch {
+        return null; // 坏 json → 当首轮,不阻断运行
+    }
+}
+export async function writeSession(runDir, meta) {
+    await writeFile(sessionPath(runDir), JSON.stringify(meta, null, 2), "utf8");
+}
+/**
+ * 决定本轮是否 --resume 复用会话:返回 sessionId(resume)或 null(冷启动)。纯函数。
+ *
+ * 防负优化:claude 的 prompt cache 有寿命(默认到 1h),间隔超过 warmMs 后 resume 必然
+ * cache miss——既读不到旧缓存、又要把更大的历史重写进新缓存,反而比冷启动+work-log 更贵。
+ * 故只在缓存窗口内 resume(省),过期则回退冷启动(不亏)。warmMs<=0 关闭阈值(永远 resume)。
+ */
+export function pickResumeId(prior, now, warmMs, currentModel = null) {
+    if (!prior)
+        return null;
+    if (prior.model !== currentModel)
+        return null;
+    if (warmMs > 0 && now - prior.lastRunAt > warmMs)
+        return null;
+    return prior.sessionId;
+}

package/dist/token.js

@@ -1,12 +1,17 @@
 /** 用机器令牌为某 agent 换取 per-launch 的 sk_agent_*。 */
-export async function mintAgentToken(serverUrl, machineToken, handle, displayName, fetchImpl = fetch) {
+export async function mintAgentToken(serverUrl, machineToken, handle, displayName, wakeThreadRoot, fetchImpl = fetch) {
     const res = await fetchImpl(`${serverUrl}/daemon/agents/token`, {
         method: "POST",
         headers: {
             authorization: `Bearer ${machineToken}`,
             "content-type": "application/json",
         },
-        body: JSON.stringify(displayName ? { handle, displayName } : { handle }),
+        // 把本轮唤醒的线程根钉到 per-launch 令牌:服务端据此让 task/消息默认绑/回当前线程。
+        body: JSON.stringify({
+            handle,
+            ...(displayName ? { displayName } : {}),
+            ...(wakeThreadRoot ? { wakeThreadRoot } : {}),
+        }),
     });
     const body = (await res.json().catch(() => null));
     if (!res.ok || !body?.success || !body.data) {

package/dist/workspace-import.js

@@ -71,7 +71,7 @@ export function stripActiveContext(md) {
     }
     const replacement = [
         lines[start], // 原 `## Active Context` 标题
-        "<!-- (导入时已清空:raft 的在办任务/任务 id 不属于本 OpenSlock。开工时在此重新记录当前进度。) -->",
+        "<!-- (导入时已清空:raft 的在办任务/任务 id 不属于本工作区。开工时在此重新记录当前进度。) -->",
         "",
     ];
     return [...lines.slice(0, start), ...replacement, ...lines.slice(end)].join("\n");

package/dist/workspace.js

@@ -72,6 +72,16 @@ export async function prepareWorkspace(input) {
     }
     return { dir, crewDir, systemPromptPath, memory, homeDir, runDir, workLogPath, workLog, agentSessionId, sessionResume };
 }
+/**
+ * 冷启动时轮换会话 id:写入新 uuid 到 <runDir>/.session 并返回。
+ * 已有会话但本轮决定不续用(warm 窗口过期 / CREW_RESUME=off)时调用——起一个全新会话,
+ * 避免拿已存在的 id 走 `--session-id`(claude 会判定 id 冲突),同时保持「一线程一(当前)会话」。
+ */
+export async function rotateAgentSession(runDir) {
+    const id = randomUUID();
+    await writeFile(join(runDir, ".session"), id, "utf8");
+    return id;
+}
 /**
  * MEMORY.md 种子骨架:分层记忆的"索引 + Active Context"结构。
  * 第一次准备工作区时写入;之后 agent 自己维护(系统提示词里有协议)。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "ws": "^8",
-    "@nowcrew/cli": "^0.1.0"
+    "@nowcrew/cli": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",