@nowcrew/daemon 0.4.3 → 0.4.5

package/dist/config.js

@@ -33,6 +33,6 @@ 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 ?? "OpenSlock",
+        productName: env.CREW_PRODUCT_NAME ?? "nowcrew",
     };
 }

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/main.js

@@ -11,6 +11,7 @@ import { detectDaemonLang, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
 import { runAgent } from "./runner.js";
 import { serve } from "./serve.js";
+import { initSlog, flushSlog } from "./slog.js";
 async function main() {
     const lang = detectDaemonLang();
     const td = (message) => translateDaemon(lang, message);
@@ -64,6 +65,7 @@ async function main() {
         process.exit(2);
     }
     process.stdout.write(`\n🚀 ${td("Waking agent")} "${values.agent}" ${td("for channel")} ${values.channel}\n\n`);
+    initSlog(config.serverUrl, config.machineToken); // 一次性 run 模式也上报 SLS(runner 里的埋点生效)
     const result = await runAgent(config, {
         handle: values.agent,
         channelId: values.channel,
@@ -71,6 +73,7 @@ async function main() {
         ...(values.display ? { displayName: values.display } : {}),
     });
     process.stdout.write(`\n— ${td("agent exited")} (code ${result.exitCode}), ${td("activities")}: ${result.activities.length} —\n`);
+    await flushSlog();
     process.exit(result.exitCode);
 }
 main().catch((e) => {

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,12 @@
 /**
- * 系统提示词与唤醒提示词构造(OpenSlock 自有设计)。
+ * 系统提示词与唤醒提示词构造(nowcrew 自有设计)。
  *
- * 描述的是 OpenSlock 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
+ * 描述的是 nowcrew 自身的 crew CLI 命令面与运行约定:crew-only 通信、一命令一调用、
  * claim-before-work、freshness/draft、"做完所有事再停"、inbox notice 语义、
  * 分层记忆与压缩安全、协作礼仪。措辞为本项目原创。
  */
 export function buildSystemPrompt(ctx) {
-    const product = ctx.productName ?? "OpenSlock";
+    const product = ctx.productName ?? "nowcrew";
     return `你是 "${ctx.handle}",${product}(一个让人类与 AI agent 协作的共享工作区)中的 AI 成员。${product} 为可能运行在不同机器上的人与 agent 提供共享的消息服务。
 
 ## 你是谁
@@ -82,6 +82,7 @@ CRITICAL 规则:
 
 ## 沟通风格
 用户看不到你的内部推理,所以:收到任务先确认并简述计划;多步工作发简短进度("正在做 2/3…");完成后总结结果。每条一两句,别刷屏。
+- 完成汇报要直接说“已在当前线程汇报”或“已在任务线程汇报”,并说明“task #N 已置为 in_review”等事实。不要写“通过 ${product} 线程汇报”这类产品名+线程的生硬说法。
 
 ## Workspace 与分层记忆(CRITICAL — 索引+按需,配合上面的并行规则)
 你的持久记忆在 \`$CREW_HOME\`(跨你所有任务共享),分三层:

package/dist/runner.js

@@ -9,10 +9,11 @@ import { prepareWorkspace, rotateAgentSession } from "./workspace.js";
 import { buildSystemPrompt, buildWakePrompt } from "./prompt.js";
 import { spawnClaude } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
-import { spawnKimi } from "./runtimes/kimi.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 { toConsoleLines } from "./console.js";
+import { dslog } from "./slog.js";
 // 注入提示词的 MEMORY.md 上限:只喂索引/角色,避免把膨胀的记忆全塞进上下文。
 const MEMORY_INJECT_CAP = 6000;
 const ICON = {
@@ -45,9 +46,22 @@ onConsole = () => { }) {
     // 只决定「是否续用」:既有会话(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 rotated = !!(ws.agentSessionId && ws.sessionResume && !resuming);
+    const launchSessionId = rotated ? await rotateAgentSession(ws.runDir) : ws.agentSessionId;
+    // resume 决策是「会话为什么没续上/为什么重开」的直接证据,把判定依据全量留痕
+    dslog("session.resume_decision", resuming ? "续用上轮会话 (--resume)" : "冷启动新会话", {
+        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
+        task_key: input.taskKey, runtime, model: currentModel,
+        resuming, rotated, session_id: launchSessionId,
+        prior_session_id: prior?.sessionId ?? null,
+        prior_age_ms: prior ? Date.now() - prior.lastRunAt : null,
+        warm_ms: config.resumeWarmMs,
+        decision_reason: !supportsNativeResume ? "runtime_no_resume"
+            : !config.resume ? "resume_disabled"
+                : !ws.sessionResume ? "first_run"
+                    : resuming ? "warm_resume"
+                        : "warm_window_expired_or_model_changed",
+    });
     const systemPrompt = buildSystemPrompt({
         handle: input.handle,
         channelId: input.channelId,
@@ -63,8 +77,9 @@ onConsole = () => { }) {
     });
     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 wakePrompt = resuming
@@ -73,7 +88,7 @@ onConsole = () => { }) {
     const childEnv = {
         ...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,
@@ -95,10 +110,10 @@ onConsole = () => { }) {
         // 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 }
+        // 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" } : {}),
@@ -111,6 +126,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,
@@ -122,6 +138,7 @@ onConsole = () => { }) {
                 wakePrompt: `${systemPrompt}\n\n${wakePrompt}`,
                 dangerous: config.dangerous,
                 ...(currentModel ? { model: currentModel } : {}),
+                ...(cfg.reasoning ? { reasoning: cfg.reasoning } : {}),
                 env: childEnv,
             })
             : runtime === "kimi"
@@ -137,6 +154,12 @@ onConsole = () => { }) {
                 : (() => {
                     throw new Error(`unsupported runtime: ${runtime}`);
                 })();
+    // 记下 OS 进程号:排查「进程被谁杀的/是否 OOM」时可与系统日志对齐
+    dslog("run.spawned", `${runtime} 进程已拉起 (pid ${child.pid})`, {
+        run_id: input.runId, agent_handle: input.handle, channel_id: input.channelId,
+        task_key: input.taskKey, runtime, model: currentModel,
+        os_pid: child.pid ?? null, session_id: launchSessionId, resume: resuming,
+    });
     // 4) 逐行解析 stdout → 归一化 → 回调;顺带抓 session_id(记 lastRunAt 供 warm-window)+ token usage(度量)
     const activities = [];
     // 身份是本轮下发的 launchSessionId;仍兜底采 claude 自报的 session_id(理应一致)。
@@ -176,17 +199,22 @@ 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) {
         // force:兜底回帖锚定本轮触发消息的线程,语义上必须送达;不 force 时 agent(-p 单发不跑
@@ -222,7 +250,45 @@ onConsole = () => { }) {
         process.stdout.write(`📊 tokens: in=${u.inputTokens} out=${u.outputTokens} cache_read=${u.cacheReadTokens} cache_create=${u.cacheCreationTokens}` +
             `${u.costUsd != null ? ` cost=$${u.costUsd.toFixed(4)}` : ""} ${resuming ? "(resumed)" : "(fresh)"}\n`);
     }
-    return { exitCode, activities, model: observedModel, runtime, resumed: resuming, ...(usage ? { usage } : {}) };
+    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] ?? "·";

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

@@ -4,6 +4,8 @@
  */
 import { WebSocket } from "ws";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { runAgent } from "./runner.js";
 import { collectMachineHello } from "./machine-info.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
@@ -23,6 +25,9 @@ export function serve(config, opts = {}) {
     let ws = null;
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
+    let connectedAt = 0; // 本次 WS 连接建立时刻(断开日志算在线时长用)
+    initSlog(config.serverUrl, config.machineToken);
+    dslog("daemon.start", "daemon 常驻模式启动", { server_url: config.serverUrl, runtime: config.runtimeBin });
     // 并行调度:同一 agent 可并行处理多个【不同任务】(线程/频道),每任务隔离 cwd+work-log。
     // - running:正在跑的「agent:任务」去重键(同一任务重复唤醒才跳过)。
     // - agentSlots:每 agent 当前并行数;超过 MAX_PARALLEL 的进 FIFO 队列(不丢)。
@@ -56,7 +61,11 @@ export function serve(config, opts = {}) {
         ws = new WebSocket(wsUrl);
         ws.on("open", () => {
             backoff = 1000;
+            connectedAt = Date.now();
             log(`🔌 已连接控制面 ${config.serverUrl}`);
+            dslog("daemon.ws_open", "已连接控制面", { server_url: config.serverUrl });
+            // 连上了才有机会把离线期间(断连原因/退出前)落盘的日志补传上去
+            void drainSpool();
             // 上报本机信息 (hostname/os/daemon 版本/已装 runtimes)
             void collectMachineHello(config.agentsRoot)
                 .then((hello) => {
@@ -81,10 +90,17 @@ export function serve(config, opts = {}) {
             // 库已重置)。不能静默丢弃这帧——否则只表现为神秘的「每 1s 重连」循环。打印可执行
             // 提示,并把退避拉满,避免无意义高频重连刷屏 server(凭证失配不会靠重试自愈,
             // 需在 NowCrew 重新 Add Computer 拿新连接命令)。
+            if (msg.type === "ready") {
+                // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
+                const r = msg;
+                setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                return;
+            }
             if (msg.type === "error") {
                 if (msg.code === "UNAUTHENTICATED") {
                     log(`🛑 控制面拒绝鉴权:机器凭证无效或已吊销 (UNAUTHENTICATED)。`);
                     log(`   请在 NowCrew 重新 "Add Computer" 获取新的连接命令,再到本机重跑(当前 --api-key 已失效)。`);
+                    dslog("daemon.ws_auth_rejected", "控制面拒绝鉴权:机器凭证无效或已吊销", { level: "ERROR" });
                     backoff = maxBackoff; // 退避到最大,停止每秒重连刷屏
                 }
                 return;
@@ -140,16 +156,31 @@ export function serve(config, opts = {}) {
             const threadId = msg.wake?.threadId;
             const taskKey = threadId ?? msg.channelId;
             const key = `${msg.agentHandle}:${taskKey}`;
+            // run_id 贯穿本轮全链路(wake→start→resume 决策→end),SLS 按 run_id 一查即得单轮时间线
+            const runId = randomUUID();
+            const runKeys = {
+                run_id: runId, agent_handle: msg.agentHandle, channel_id: msg.channelId,
+                thread_id: threadId ?? null, task_key: taskKey,
+            };
+            dslog("run.wake_received", `收到唤醒 ${msg.agentHandle}`, {
+                ...runKeys, reason: msg.reason ?? "", sender: msg.wake?.senderHandle,
+                content_preview: (msg.wake?.content ?? "").replace(/\s+/g, " ").slice(0, 120),
+            });
             if (running.has(key)) {
                 log(`↩︎ 跳过(该任务已在运行): ${key}`);
+                dslog("run.dedupe_skip", "跳过唤醒:该任务已在运行", { level: "WARN", ...runKeys });
                 return;
             }
             running.add(key);
             // 并行槽:同 agent 超过 MAX_PARALLEL 个任务时在此排队(不丢),有空位再跑。
+            const slotWaitStart = Date.now();
             await acquireSlot(msg.agentHandle);
+            const queueMs = Date.now() - slotWaitStart;
             const threadLabel = threadId ?? null;
             const from = msg.wake?.senderHandle ?? "?";
             const incoming = msg.wake?.content ?? "";
+            dslog("run.start", `开始运行 ${msg.agentHandle}`, { ...runKeys, queue_ms: queueMs });
+            const runStartedAt = Date.now();
             log(`\n${"─".repeat(56)}`);
             log(`🔔 唤醒 agent=${msg.agentHandle}  reason=${msg.reason ?? "?"}`);
             log(`   channel = ${msg.channelId}`);
@@ -226,6 +257,7 @@ export function serve(config, opts = {}) {
                     handle: msg.agentHandle,
                     channelId: msg.channelId,
                     taskKey, // 每任务隔离 cwd + work-log(并行不冲突)
+                    runId, // 贯穿 SLS 日志的单轮关联键
                     // 唤醒锚点是具体消息(非纯频道唤醒)时,把它透传下去,供 `crew task create` 锚定到该消息。
                     ...(threadId ? { wakeMessageId: threadId } : {}),
                     ...(msg.wake?.content ? { wake: `你被唤醒(${msg.reason}): ${msg.wake.content}\n用 ${readCmd} 读${threadId ? "本线程" : "频道"}后按需处理。${reasonHint}${ackHint}${threadHint}${attHint}` } : {}),
@@ -252,16 +284,50 @@ export function serve(config, opts = {}) {
                     }
                     catch { /* ws 非 OPEN,忽略(用量非关键路径,丢一轮不阻塞) */ }
                 }
-                reportActivity({ kind: "done", label: "本轮结束" });
-                reportConsole({ stream: "result", text: "● 本轮结束" });
-                log(`✅ agent=${msg.agentHandle} 本轮完成`);
+                // run.end 是排查「任务没跑完就本轮结束」的核心证据:退出码 + 时长 + 最后活动 +
+                // 是否 resume + 用量。exit_code!=0 或时长异常短都值得追。
+                const lastActivity = result.activities.length
+                    ? result.activities[result.activities.length - 1].kind
+                    : null;
+                dslog("run.end", `本轮结束 ${msg.agentHandle} (exit=${result.exitCode})`, {
+                    ...runKeys,
+                    level: result.exitCode === 0 ? "INFO" : "ERROR",
+                    exit_code: result.exitCode, duration_ms: Date.now() - runStartedAt,
+                    runtime: result.runtime, model: result.model, resumed: result.resumed,
+                    session_id: result.sessionId,
+                    activity_count: result.activities.length, last_activity: lastActivity,
+                    ...(result.usage ? {
+                        tokens_input: result.usage.inputTokens, tokens_output: result.usage.outputTokens,
+                        cache_read: result.usage.cacheReadTokens, cache_creation: result.usage.cacheCreationTokens,
+                        ...(result.usage.costUsd != null ? { cost_usd: result.usage.costUsd } : {}),
+                    } : {}),
+                });
+                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}`);
+                dslog("run.error", `runAgent 失败: ${e.message}`, {
+                    level: "ERROR", ...runKeys, duration_ms: Date.now() - runStartedAt,
+                    error_message: e.message, error_stack: e.stack,
+                });
             }
             finally {
                 running.delete(key);
                 releaseSlot(msg.agentHandle);
+                void flushSlog(); // 每轮收尾冲一次,保证 run.end 尽快可查
             }
         });
         ws.on("close", (code) => {
@@ -275,6 +341,14 @@ export function serve(config, opts = {}) {
                 log(`   请在 NowCrew 重新 "Add Computer" 获取新连接命令再重跑(当前 --api-key 已失效)。`);
             }
             log(`🔁 控制面断开,${Math.round(backoff / 1000)}s 后重连`);
+            // 此刻 server 大概率不可达 → 这条会落 spool,重连 drainSpool 时补传;
+            // ts 是现在(断开时刻),排查「daemon 为什么断」以它对齐 server 侧 machine_disconnected。
+            dslog("daemon.ws_close", `控制面断开 (code ${code})`, {
+                level: "WARN", close_code: code, backoff_ms: backoff,
+                online_ms: connectedAt ? Date.now() - connectedAt : null,
+                running_tasks: [...running].join(","),
+            });
+            void flushSlog();
             setTimeout(connect, backoff);
             backoff = Math.min(backoff * 2, maxBackoff);
         });

package/dist/slog.js

@@ -0,0 +1,214 @@
+/**
+ * daemon 侧 SLS 日志客户端 —— 透过 server 的 POST /ingest/logs 上报(daemon 不直连 SLS)。
+ *
+ * 断线补传(关键设计):
+ *   - 每条日志的 ts = 事件**实际发生时间**(epoch ms)。server 把它写成 SLS __time__,
+ *     所以补传的日志仍落在正确时间点,时间线不乱;补传条目带 spooled=true + reported_at 归因。
+ *   - 上报失败(server 不可达/断网)→ 落本地 spool(~/.crew/logs/sls-spool/*.jsonl);
+ *     下次 WS 重连成功(drainSpool)时补传。「daemon 为什么断开」的现场就靠这批日志还原。
+ *   - 进程退出(SIGINT/SIGTERM/exit)→ 残余队列同步落 spool,下次启动补传。
+ *
+ * 永不抛错、永不阻塞业务;未 init 时所有调用是 no-op(兼容单测/一次性 run 模式无凭证场景)。
+ */
+import { hostname } from "node:os";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
+const FLUSH_INTERVAL_MS = 1500;
+const BATCH_SIZE = 50;
+const SPOOL_MAX_FILES = 50; // spool 目录文件数上限,超出丢最旧(日志非关键数据,防无限膨胀)
+const SPOOL_DRAIN_CAP = 1000; // 单次补传条数上限
+let cfg = null;
+let defaults = {};
+let queue = [];
+let timer = null;
+let flushing = false;
+let lastErrorAt = 0;
+function spoolDir() {
+    return process.env.CREW_SLS_SPOOL_DIR ?? join(homedir(), ".crew", "logs", "sls-spool");
+}
+/** serve/run 启动时调用一次;disabled(CREW_SLS_LOG=off)则保持 no-op。 */
+export function initSlog(serverUrl, machineToken) {
+    if (process.env.CREW_SLS_LOG === "off" || process.env.CREW_SLS_LOG === "0")
+        return;
+    cfg = { serverUrl: serverUrl.replace(/\/+$/, ""), token: machineToken };
+    defaults = { host: hostname(), pid: process.pid };
+    // 退出兜底:残余队列同步落 spool(exit 回调只能做同步工作,append 正合适)
+    process.once("exit", () => spoolRemainingSync());
+    for (const sig of ["SIGINT", "SIGTERM"]) {
+        process.once(sig, () => {
+            spoolRemainingSync();
+            process.exit(sig === "SIGINT" ? 130 : 143);
+        });
+    }
+}
+/** 追加默认关联字段(如 ready 帧下发的 machine_id),之后每条日志自动带上。 */
+export function setSlogDefaults(fields) {
+    defaults = { ...defaults, ...fields };
+}
+/** 记一条结构化日志(异步批量上报;失败自动落 spool)。 */
+export function dslog(eventType, message, fields = {}) {
+    if (!cfg)
+        return;
+    const { level, ...rest } = fields;
+    queue.push({
+        ts: Date.now(),
+        level: level ?? (eventType.includes("error") || eventType.includes("failed") ? "ERROR" : "INFO"),
+        event_type: eventType,
+        message,
+        fields: compact({ ...defaults, ...rest }),
+    });
+    if (queue.length >= BATCH_SIZE) {
+        void flushSlog();
+        return;
+    }
+    if (!timer) {
+        timer = setTimeout(() => void flushSlog(), FLUSH_INTERVAL_MS);
+        timer.unref?.();
+    }
+}
+/** 把内存队列冲到 server;失败整批落 spool(保 ts 不丢现场)。 */
+export async function flushSlog() {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    if (!cfg || flushing || queue.length === 0)
+        return;
+    flushing = true;
+    const batch = queue;
+    queue = [];
+    try {
+        await post(batch);
+    }
+    catch (e) {
+        appendSpool(batch);
+        warnThrottled(`SLS 日志上报失败,已落本地 spool(${batch.length} 条): ${e.message}`);
+    }
+    finally {
+        flushing = false;
+    }
+}
+/**
+ * 补传本地 spool(WS 重连成功后调用):上次断连/退出前落盘的现场日志,
+ * 此刻才有机会送出。条目加 spooled=true,ts 仍是当时的发生时间。
+ */
+export async function drainSpool() {
+    if (!cfg)
+        return;
+    const dir = spoolDir();
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith(".jsonl")).sort();
+    }
+    catch {
+        return; // 目录不存在 = 无积压
+    }
+    if (files.length === 0)
+        return;
+    const entries = [];
+    const consumed = [];
+    for (const f of files) {
+        if (entries.length >= SPOOL_DRAIN_CAP)
+            break;
+        const path = join(dir, f);
+        try {
+            const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const e = JSON.parse(line);
+                    if (typeof e.ts === "number" && typeof e.event_type === "string") {
+                        entries.push({ ...e, fields: { ...(e.fields ?? {}), spooled: true } });
+                    }
+                }
+                catch { /* 坏行跳过 */ }
+            }
+            consumed.push(path);
+        }
+        catch { /* 读失败跳过该文件 */ }
+    }
+    if (entries.length === 0) {
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        return;
+    }
+    try {
+        for (let i = 0; i < entries.length; i += 100) {
+            await post(entries.slice(i, i + 100));
+        }
+        for (const p of consumed)
+            try {
+                unlinkSync(p);
+            }
+            catch { /* 忽略 */ }
+        process.stdout.write(`📮 已补传离线期间的 ${entries.length} 条 SLS 日志\n`);
+    }
+    catch (e) {
+        warnThrottled(`spool 补传失败,留待下次重连: ${e.message}`); // 文件保留,下次再试
+    }
+}
+// ── 内部 ─────────────────────────────────────────────────────────
+async function post(entries) {
+    const res = await fetch(`${cfg.serverUrl}/ingest/logs`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${cfg.token}`, "content-type": "application/json" },
+        body: JSON.stringify({
+            entries: entries.map((e) => ({
+                ts: e.ts, level: e.level, event_type: e.event_type, message: e.message, fields: e.fields,
+            })),
+        }),
+        signal: AbortSignal.timeout(8000),
+    });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+}
+function appendSpool(entries) {
+    try {
+        const dir = spoolDir();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        rotateSpool(dir);
+        const file = join(dir, `daemon-${Date.now()}-${process.pid}.jsonl`);
+        appendFileSync(file, entries.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    }
+    catch { /* spool 也失败(磁盘只读等):放弃这批,不能影响业务 */ }
+}
+/** 目录内文件超上限时删最旧,防止长期断网把磁盘写满。 */
+function rotateSpool(dir) {
+    try {
+        const files = readdirSync(dir)
+            .filter((f) => f.endsWith(".jsonl"))
+            .map((f) => ({ f, mtime: statSync(join(dir, f)).mtimeMs }))
+            .sort((a, b) => a.mtime - b.mtime);
+        for (const { f } of files.slice(0, Math.max(0, files.length - SPOOL_MAX_FILES + 1))) {
+            unlinkSync(join(dir, f));
+        }
+    }
+    catch { /* 忽略 */ }
+}
+function spoolRemainingSync() {
+    if (queue.length === 0)
+        return;
+    const batch = queue;
+    queue = [];
+    appendSpool(batch);
+}
+function warnThrottled(msg) {
+    const now = Date.now();
+    if (now - lastErrorAt > 60_000) {
+        lastErrorAt = now;
+        process.stderr.write(`[slog] ${msg}\n`);
+    }
+}
+function compact(fields) {
+    const out = {};
+    for (const [k, v] of Object.entries(fields)) {
+        if (v === undefined)
+            continue;
+        out[k] = typeof v === "string" && v.length > 4096 ? `${v.slice(0, 4096)}…(truncated)` : v;
+    }
+    return out;
+}

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.3",
+  "version": "0.4.5",
   "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.0"
+    "@nowcrew/cli": "^0.3.1"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.0.0",
     "@types/ws": "^8",
     "tsx": "^4.19.0",