@nowcrew/daemon 0.5.20 → 0.5.22

package/dist/console-formatter.js

@@ -0,0 +1,60 @@
+/**
+ * 单次 runtime execution 的 console 格式化器。
+ * 用 tool_use id 关联 Read 结果,避免将整文件作为普通 tool_result 倾泻到终端。
+ */
+import { buildFilePreview } from "./console-payload.js";
+import { toConsoleLines, TOOL_RESULT_CAP } from "./console.js";
+import { parseUnifiedDiff } from "./unified-diff.js";
+const extract = (content) => {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.map((item) => item && typeof item === "object" && typeof item.text === "string"
+        ? item.text : "").filter(Boolean).join("\n");
+};
+const clip = (text) => text.length > TOOL_RESULT_CAP
+    ? `${text.slice(0, TOOL_RESULT_CAP)}… (+${text.length - TOOL_RESULT_CAP})`
+    : text;
+export function createConsoleFormatter() {
+    const pending = new Map();
+    return {
+        format(event) {
+            const rec = event && typeof event === "object" ? event : {};
+            const message = rec.message && typeof rec.message === "object" ? rec.message : undefined;
+            if (rec.type === "assistant" && Array.isArray(message?.content)) {
+                for (const block of message.content) {
+                    if (block.type === "tool_use" && block.id && block.name) {
+                        pending.set(block.id, { name: block.name, ...(block.input ? { input: block.input } : {}) });
+                    }
+                }
+            }
+            if (rec.type === "user" && Array.isArray(message?.content)) {
+                const out = [];
+                for (const block of message.content) {
+                    if (block.type !== "tool_result")
+                        continue;
+                    const text = extract(block.content);
+                    if (!text)
+                        continue;
+                    const tool = block.tool_use_id ? pending.get(block.tool_use_id) : undefined;
+                    if (block.tool_use_id)
+                        pending.delete(block.tool_use_id);
+                    if (!block.is_error && tool?.name === "Read" && typeof tool.input?.file_path === "string") {
+                        const start = typeof tool.input.offset === "number" && Number.isSafeInteger(tool.input.offset)
+                            ? Math.max(1, tool.input.offset) : 1;
+                        const preview = buildFilePreview("read", tool.input.file_path, text, start);
+                        out.push({ stream: "tool_result", text: `Read ${preview.totalLines} line(s) from ${preview.path}`, payload: preview });
+                        continue;
+                    }
+                    const patch = block.is_error ? null : parseUnifiedDiff(text);
+                    out.push(patch
+                        ? { stream: "tool_result", text: `Changed ${patch.files.length} file(s): +${patch.additions} -${patch.deletions}`, payload: patch }
+                        : { stream: "tool_result", text: clip(text) });
+                }
+                return out;
+            }
+            return toConsoleLines(event);
+        },
+    };
+}

package/dist/console-payload.js

@@ -0,0 +1,73 @@
+/**
+ * AgentConsole 的结构化展示协议与有界构造器。
+ * 所有代码/文件预览在 daemon 边界裁剪,避免 server/web 接收整文件。
+ */
+export const CONSOLE_PREVIEW_ROWS = 12;
+export const CONSOLE_PREVIEW_HEAD_ROWS = 8;
+export const CONSOLE_DIFF_ROWS = 40;
+export const CONSOLE_ROW_CHARS = 240;
+const clipRow = (text) => text.length > CONSOLE_ROW_CHARS
+    ? `${text.slice(0, CONSOLE_ROW_CHARS)}…`
+    : text;
+/** 头 8 + 尾 4,中间显式 omitted;小文件全部显示。 */
+export function buildFilePreview(operation, path, content, startLine = 1) {
+    const lines = content ? content.split("\n") : [];
+    const visible = lines.length <= CONSOLE_PREVIEW_ROWS
+        ? lines.map((text, index) => ({ type: "line", line: startLine + index, text: clipRow(text) }))
+        : [
+            ...lines.slice(0, CONSOLE_PREVIEW_HEAD_ROWS).map((text, index) => ({
+                type: "line", line: startLine + index, text: clipRow(text),
+            })),
+            { type: "omitted", count: lines.length - CONSOLE_PREVIEW_ROWS },
+            ...lines.slice(-4).map((text, index) => ({
+                type: "line", line: startLine + lines.length - 4 + index, text: clipRow(text),
+            })),
+        ];
+    return {
+        kind: "file_preview",
+        operation,
+        path,
+        totalLines: lines.length,
+        totalBytes: Buffer.byteLength(content, "utf8"),
+        rows: visible,
+    };
+}
+/** old/new 片段转紧凑带双行号 diff;变更中段超过预算时裁剪。 */
+export function buildSnippetDiff(path, oldText, newText) {
+    const oldLines = oldText ? oldText.split("\n") : [];
+    const newLines = newText ? newText.split("\n") : [];
+    let prefix = 0;
+    while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+        prefix++;
+    let oldEnd = oldLines.length;
+    let newEnd = newLines.length;
+    while (oldEnd > prefix && newEnd > prefix && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+        oldEnd--;
+        newEnd--;
+    }
+    const rows = [];
+    const contextStart = Math.max(0, prefix - 2);
+    for (let index = contextStart; index < prefix; index++) {
+        rows.push({ type: "context", oldLine: index + 1, newLine: index + 1, text: clipRow(oldLines[index]) });
+    }
+    for (let index = prefix; index < oldEnd; index++) {
+        rows.push({ type: "delete", oldLine: index + 1, newLine: null, text: clipRow(oldLines[index]) });
+    }
+    for (let index = prefix; index < newEnd; index++) {
+        rows.push({ type: "add", oldLine: null, newLine: index + 1, text: clipRow(newLines[index]) });
+    }
+    for (let offset = 0; offset < Math.min(2, oldLines.length - oldEnd); offset++) {
+        rows.push({ type: "context", oldLine: oldEnd + offset + 1, newLine: newEnd + offset + 1, text: clipRow(oldLines[oldEnd + offset]) });
+    }
+    const additions = Math.max(0, newEnd - prefix);
+    const deletions = Math.max(0, oldEnd - prefix);
+    if (rows.length <= CONSOLE_DIFF_ROWS)
+        return { kind: "diff_rows", files: [{ path, rows }], additions, deletions };
+    const head = rows.slice(0, 28);
+    const tail = rows.slice(-11);
+    return {
+        kind: "diff_rows",
+        files: [{ path, rows: [...head, { type: "omitted", oldCount: rows.length - 39, newCount: rows.length - 39 }, ...tail] }],
+        additions, deletions, truncated: true,
+    };
+}

package/dist/console.js

@@ -13,6 +13,8 @@
  * kimi(OpenAI 消息风格行)。
  */
 import { detectDaemonLang, translateDaemon } from "./i18n.js";
+import { buildFilePreview, buildSnippetDiff } from "./console-payload.js";
+import { parseUnifiedDiff } from "./unified-diff.js";
 /** 单条工具返回正文上限(超出截断并标注),避免单条把终端/DB 撑爆。 */
 export const TOOL_RESULT_CAP = 4000;
 /** 工具输入摘要上限(标题行那一段)。 */
@@ -95,10 +97,10 @@ function toolPayload(name, input) {
         return { kind: "command", command: clip(input.command, PAYLOAD_TEXT_CAP) };
     }
     if (name === "Edit" && typeof input.file_path === "string") {
-        return diffPayload(input.file_path, input.old_string, input.new_string);
+        return buildSnippetDiff(input.file_path, typeof input.old_string === "string" ? input.old_string : "", typeof input.new_string === "string" ? input.new_string : "");
     }
     if (name === "Write" && typeof input.file_path === "string" && typeof input.content === "string") {
-        return diffPayload(input.file_path, "", input.content);
+        return buildFilePreview("write", input.file_path, input.content);
     }
     if (name === "TodoWrite") {
         const todos = normalizeTodos(input.todos);
@@ -125,7 +127,7 @@ function toolUseChunks(name, input) {
             chunks.push({
                 stream: "tool",
                 text: `⏺ Edit(${clip(file, TOOL_INPUT_CAP)})`,
-                payload: diffPayload(file, rec.old_string, rec.new_string),
+                payload: buildSnippetDiff(file, typeof rec.old_string === "string" ? rec.old_string : "", typeof rec.new_string === "string" ? rec.new_string : ""),
             });
         }
         if (chunks.length)
@@ -170,8 +172,12 @@ function codexItemChunks(item, td) {
                 },
             }];
         const output = item.aggregated_output?.trim();
-        if (output)
-            out.push({ stream: "tool_result", text: clip(output, TOOL_RESULT_CAP) });
+        if (output) {
+            const patch = parseUnifiedDiff(output);
+            out.push(patch
+                ? { stream: "tool_result", text: `Changed ${patch.files.length} file(s): +${patch.additions} -${patch.deletions}`, payload: patch }
+                : { stream: "tool_result", text: clip(output, TOOL_RESULT_CAP) });
+        }
         return out;
     }
     if (item.type === "file_change" && Array.isArray(item.changes)) {

package/dist/daemon-startup-error.js

@@ -0,0 +1,30 @@
+import { formatDaemonText, } from "./i18n.js";
+const PROFILE_MESSAGE = "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If this profile is managed as a service, use 'crew-daemon stop --profile {{profileName}}' or 'crew-daemon restart --profile {{profileName}}'.";
+const MANUAL_MESSAGE = "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If it is managed as a service, use 'crew-daemon stop --profile <name>' or 'crew-daemon restart --profile <name>'.";
+export class DaemonAlreadyRunningError extends Error {
+    ownerPid;
+    agentsRoot;
+    journalPath;
+    serverUrl;
+    profileName;
+    constructor(details) {
+        super(`Daemon is already running (PID=${details.ownerPid})`, { cause: details.cause });
+        this.name = "DaemonAlreadyRunningError";
+        this.ownerPid = details.ownerPid;
+        this.agentsRoot = details.agentsRoot;
+        this.journalPath = details.journalPath;
+        this.serverUrl = details.serverUrl;
+        if (details.profileName !== undefined)
+            this.profileName = details.profileName;
+    }
+}
+export function formatDaemonStartupError(error, lang) {
+    if (!(error instanceof DaemonAlreadyRunningError))
+        return null;
+    return formatDaemonText(lang, error.profileName === undefined ? MANUAL_MESSAGE : PROFILE_MESSAGE, {
+        ownerPid: error.ownerPid,
+        agentsRoot: error.agentsRoot,
+        journalPath: error.journalPath,
+        ...(error.profileName === undefined ? {} : { profileName: error.profileName }),
+    });
+}

package/dist/execution-backend.js

@@ -1,11 +1,44 @@
+import { isJobObjectSupported } from "./win32-job-object.js";
+/** 灰度开关:默认关。只有显式打开且运行时探测成功,win32 才翻为 supported。 */
+const GRAYSCALE_ENV = "CREW_WINDOWS_JOB_OBJECT";
+function grayscaleEnabled() {
+    const flag = process.env[GRAYSCALE_ENV];
+    return flag === "1" || flag === "true";
+}
+let cachedProbe;
+/**
+ * 默认探测:灰度关 → 一律 false(行为与今日一致)。灰度开 → 同步探测 koffi/kernel32 一次并缓存。
+ * 同步实现(createRequire),因此 `executionBackendCapability` 保持同步,不波及 serve.ts 的同步调用链。
+ */
+function defaultJobObjectProbe() {
+    if (!grayscaleEnabled())
+        return false;
+    if (cachedProbe === undefined)
+        cachedProbe = isJobObjectSupported();
+    return cachedProbe;
+}
+const WINDOWS_UNAVAILABLE_REASON = "protocol-v1 is disabled until a Windows Job Object backend owns every runtime process";
 /** Durable execution needs ownership that survives daemon crashes, not only a best-effort kill. */
-export function executionBackendCapability(platform = process.platform) {
+export function executionBackendCapability(platform = process.platform, probe = defaultJobObjectProbe) {
     if (platform === "win32") {
+        if (probe())
+            return { supported: true, backend: "windows-job-object" };
         return {
             supported: false,
             backend: "windows-job-object-unavailable",
-            reason: "protocol-v1 is disabled until a Windows Job Object backend owns every runtime process",
+            reason: WINDOWS_UNAVAILABLE_REASON,
         };
     }
     return { supported: true, backend: "posix-process-group" };
 }
+/**
+ * supervisor child 是否应通过 Job Object 拥有 runtime 树。仅当 durable + win32 + Job Object 后端已选中时为真。
+ * legacy(process-lifetime)恒为 false —— 保证灰度关/koffi 不可用时 Windows legacy 执行完全不碰 Job,
+ * 维持今日的 taskkill 语义与 fail-closed 降级承诺。
+ */
+export function ownsRuntimeViaJobObject(ownershipMode, platform = process.platform, probe) {
+    if (ownershipMode !== "durable")
+        return false;
+    const backend = executionBackendCapability(platform, probe);
+    return backend.supported && backend.backend === "windows-job-object";
+}

package/dist/execution-event-limit.js

@@ -38,6 +38,11 @@ export function boundExecutionFrame(input, maxBytes) {
     }
     else if (input.type === "execution:console" || input.type === "execution:output") {
         frame = withBoundedString(frame, "text", maxBytes, false);
+        // 富 payload 是可选增强;事件超限时先丢 payload,保留必需 text 帧。
+        if (executionFrameBytes(frame) > maxBytes && "payload" in frame) {
+            const { payload: _payload, ...withoutPayload } = frame;
+            frame = withoutPayload;
+        }
     }
     else if (input.type === "execution:rejected") {
         frame = withBoundedString(frame, "message", maxBytes, true);

package/dist/execution-protocol.js

@@ -191,6 +191,7 @@ export const ExecutionConsoleSchema = z.object({
     executionId: ExecutionIdSchema,
     stream: ConsoleStreamSchema,
     text: z.string(),
+    payload: z.record(z.string(), z.unknown()).optional(),
     seq: SequenceSchema,
     at: TimestampSchema,
 }).strict();

package/dist/execution-recovery.js

@@ -1,4 +1,6 @@
 import { join, resolve } from "node:path";
+import { JournalLockedError } from "./execution-journal.js";
+import { DaemonAlreadyRunningError } from "./daemon-startup-error.js";
 export async function reconcileExecutionJournal(journal, dependencies) {
     try {
         await journal.reconcileAfterRestart();
@@ -14,22 +16,27 @@ export async function reconcileExecutionJournal(journal, dependencies) {
         const ownerPid = typeof errorRecord.ownerPid === "number" ? errorRecord.ownerPid : undefined;
         const errorType = error instanceof Error ? error.name : typeof error;
         const errorMessage = error instanceof Error ? error.message : String(error);
+        const alreadyRunning = error instanceof JournalLockedError && ownerPid !== undefined;
         const diagnostics = {
             server_url: dependencies.serverUrl,
             agents_root: agentsRoot,
             journal_path: journalPath,
             owner_pid: ownerPid,
+            ...(dependencies.profileName === undefined ? {} : { profile_name: dependencies.profileName }),
             error_type: errorType,
             error_message: errorMessage,
         };
-        dependencies.log("execution.recovery_failed", "execution journal 恢复失败", {
-            level: "ERROR",
+        const failureEvent = alreadyRunning ? "daemon.already_running" : "execution.recovery_failed";
+        const failureMessage = alreadyRunning ? "daemon 已在运行" : "execution journal 恢复失败";
+        const failureLevel = alreadyRunning ? "WARN" : "ERROR";
+        dependencies.log(failureEvent, failureMessage, {
+            level: failureLevel,
             ...diagnostics,
         });
         dependencies.writeStderr(`${JSON.stringify({
-            level: "ERROR",
-            event_type: "execution.recovery_failed",
-            message: "execution journal 恢复失败",
+            level: failureLevel,
+            event_type: failureEvent,
+            message: failureMessage,
             ...diagnostics,
         })}\n`);
         const reportCleanupFailure = (stage, cleanupError) => {
@@ -43,14 +50,21 @@ export async function reconcileExecutionJournal(journal, dependencies) {
                 cleanup_stage: stage,
                 error_type: cleanupErrorType,
                 error_message: cleanupErrorMessage,
-                recovery_error_type: errorType,
-                recovery_error_message: errorMessage,
+                ...(alreadyRunning
+                    ? { startup_error_type: errorType, startup_error_message: errorMessage }
+                    : { recovery_error_type: errorType, recovery_error_message: errorMessage }),
             };
-            dependencies.log("execution.recovery_cleanup_failed", "execution journal 恢复失败后的清理失败", { level: "ERROR", ...cleanupDiagnostics });
+            const cleanupEvent = alreadyRunning
+                ? "daemon.already_running_cleanup_failed"
+                : "execution.recovery_cleanup_failed";
+            const cleanupMessage = alreadyRunning
+                ? "daemon 重复启动后的清理失败"
+                : "execution journal 恢复失败后的清理失败";
+            dependencies.log(cleanupEvent, cleanupMessage, { level: "ERROR", ...cleanupDiagnostics });
             dependencies.writeStderr(`${JSON.stringify({
                 level: "ERROR",
-                event_type: "execution.recovery_cleanup_failed",
-                message: "execution journal 恢复失败后的清理失败",
+                event_type: cleanupEvent,
+                message: cleanupMessage,
                 ...cleanupDiagnostics,
             })}\n`);
         };
@@ -66,6 +80,16 @@ export async function reconcileExecutionJournal(journal, dependencies) {
         catch (cleanupError) {
             reportCleanupFailure("journal_close", cleanupError);
         }
+        if (alreadyRunning) {
+            throw new DaemonAlreadyRunningError({
+                ownerPid,
+                agentsRoot,
+                journalPath,
+                serverUrl: dependencies.serverUrl,
+                ...(dependencies.profileName === undefined ? {} : { profileName: dependencies.profileName }),
+                cause: error,
+            });
+        }
         throw error;
     }
 }

package/dist/execution-runner.js

@@ -422,6 +422,7 @@ export async function runExecution(config, input, dependencies) {
                         executionId: spec.executionId,
                         stream: chunk.stream,
                         text: chunk.text,
+                        ...(chunk.payload ? { payload: chunk.payload } : {}),
                         seq: consoleSequence++,
                         at: now().toISOString(),
                     });

package/dist/execution-supervisor-child.js

@@ -1,6 +1,7 @@
 import spawn from "cross-spawn";
 import { z } from "zod";
 import { pathToFileURL } from "node:url";
+import { assignProcessToJob, createKillOnCloseJob, terminateJob, } from "./win32-job-object.js";
 const LaunchSchema = z.object({
     command: z.string().min(1),
     args: z.array(z.string()),
@@ -8,6 +9,9 @@ const LaunchSchema = z.object({
     env: z.record(z.string()),
     stdinText: z.string().optional(),
 }).strict();
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function send(message, callback) {
     if (!process.connected) {
         callback?.();
@@ -56,10 +60,17 @@ function forwardWhileWritable(source, destination) {
 }
 export function runExecutionSupervisorChild() {
     let launch = null;
+    // 是否用 Job Object 拥有 runtime 树。由 parent 依据「durable + win32 + Job Object 后端已选中」决定并下发;
+    // legacy(process-lifetime)路径恒为 false —— 关键:不能仅凭 process.platform 就建 Job,否则灰度关时
+    // legacy Windows 执行会被强行套 Job,且 koffi 加载失败会误杀 legacy runtime(退回 fail-closed 承诺被破坏)。
+    let useJobObject = false;
     let released = false;
     let runtime = null;
     let settled = false;
     let cleaningTree = false;
+    // win32:本 child 创建并持有的 Job(KILL_ON_JOB_CLOSE)。持有它 = 拥有整棵 runtime 进程树:
+    // 本进程一死(含崩溃)内核即回收 Job 内全部进程,等价于 POSIX killpg 且覆盖 supervisor 自身崩溃。
+    let jobHandle = null;
     const outputForwarders = [];
     const terminateOwnedTree = () => {
         if (cleaningTree)
@@ -68,6 +79,15 @@ export function runExecutionSupervisorChild() {
         for (const forwarder of outputForwarders)
             forwarder.discard();
         if (process.platform === "win32") {
+            // 显式一次性杀光 Job 内进程;即便这里失败,process.exit 关闭 job handle 也会触发内核回收。
+            if (jobHandle !== null) {
+                try {
+                    terminateJob(jobHandle);
+                }
+                catch {
+                    // handle 随进程退出自动关闭,KILL_ON_JOB_CLOSE 兜底。
+                }
+            }
             process.exit(1);
             return;
         }
@@ -126,6 +146,7 @@ export function runExecutionSupervisorChild() {
                 return;
             }
             launch = parsed.data;
+            useJobObject = raw.useJobObject === true;
             send({ type: "ready" });
             return;
         }
@@ -139,6 +160,18 @@ export function runExecutionSupervisorChild() {
         if (raw.type !== "release" || released || launch === null)
             return;
         released = true;
+        if (useJobObject) {
+            // 所有权链条落地(仅 durable win32):先建 Job(带 KILL_ON_JOB_CLOSE),再 spawn,spawn 后立即 assign。
+            // 建 Job 失败即无法保证所有权 → 宁可不 spawn,报 spawn-error 让上层 fail-closed。
+            try {
+                jobHandle = createKillOnCloseJob();
+            }
+            catch (error) {
+                send({ type: "runtime-spawn-error", message: `Job Object creation failed: ${messageOf(error)}` });
+                process.exit(2);
+                return;
+            }
+        }
         const child = spawn(launch.command, launch.args, {
             cwd: launch.cwd,
             env: launch.env,
@@ -146,6 +179,24 @@ export function runExecutionSupervisorChild() {
             stdio: [launch.stdinText === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         });
         runtime = child;
+        if (jobHandle !== null && child.pid !== undefined) {
+            // spawn 返回后 child.pid 同步可用,此刻立即 assign,把「assign 前已 fork 孙进程」的窗口压到最小。
+            try {
+                assignProcessToJob(jobHandle, child.pid);
+            }
+            catch (error) {
+                // 无法建立所有权:杀掉刚起的 runtime 并拆除,不让它脱离 Job 裸奔。
+                send({ type: "runtime-spawn-error", message: `AssignProcessToJobObject failed: ${messageOf(error)}` });
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // 已退出。
+                }
+                terminateOwnedTree();
+                return;
+            }
+        }
         outputForwarders.push(forwardWhileWritable(child.stdout, process.stdout), forwardWhileWritable(child.stderr, process.stderr));
         child.once("spawn", () => {
             send({ type: "runtime-started" });

package/dist/execution-supervisor.js

@@ -1,6 +1,6 @@
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { executionBackendCapability } from "./execution-backend.js";
+import { executionBackendCapability, ownsRuntimeViaJobObject } from "./execution-backend.js";
 const DEFAULT_ABORT_TIMEOUT_MS = 5_000;
 const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5_000;
 const DEFAULT_TASKKILL_TIMEOUT_MS = 5_000;
@@ -141,6 +141,8 @@ export async function startDormantSupervisor(launch, options = {}) {
         if (!backend.supported)
             throw new Error(backend.reason);
     }
+    // 仅 durable + win32 + Job Object 后端已选中才让 child 套 Job;legacy 恒 false(见 ownsRuntimeViaJobObject)。
+    const useJobObject = ownsRuntimeViaJobObject(ownershipMode, platform);
     const signalTree = options.signalTree ?? signalSupervisorTree;
     const childEntry = options.childEntry
         ?? fileURLToPath(new URL("./execution-supervisor-child.js", import.meta.url));
@@ -249,7 +251,7 @@ export async function startDormantSupervisor(launch, options = {}) {
     };
     try {
         await new Promise((resolve, reject) => {
-            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env } }, (error) => {
+            child.send({ type: "launch", launch: { ...launch, args: [...launch.args], env }, useJobObject }, (error) => {
                 if (error === null)
                     resolve();
                 else

package/dist/i18n.js

@@ -51,6 +51,8 @@ const zh = {
     "--token-stdin requires a token on standard input": "--token-stdin 需要从标准输入读取令牌",
     "Service lifecycle requires a global @nowcrew/daemon install; run npm install --global @nowcrew/daemon@latest": "服务生命周期需要全局安装 @nowcrew/daemon；请运行 npm install --global @nowcrew/daemon@latest",
     "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}": "配置 '{{profile}}' 与配置 '{{conflict}}' 解析到了同一个 agents root '{{agentsRoot}}'。请保存为唯一目录，例如：{{command}}",
+    "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If this profile is managed as a service, use 'crew-daemon stop --profile {{profileName}}' or 'crew-daemon restart --profile {{profileName}}'.": "daemon 已在运行（PID={{ownerPid}}），agents root 为 '{{agentsRoot}}'。日志目录：'{{journalPath}}'。不要删除活跃进程持有的 journal 锁。请先停止现有 daemon 再重试；如果此 profile 由系统服务管理，请使用 'crew-daemon stop --profile {{profileName}}' 或 'crew-daemon restart --profile {{profileName}}'。",
+    "Daemon is already running (PID={{ownerPid}}) for agents root '{{agentsRoot}}'. Journal: '{{journalPath}}'. Do not delete the active journal lock. Stop the existing daemon before retrying. If it is managed as a service, use 'crew-daemon stop --profile <name>' or 'crew-daemon restart --profile <name>'.": "daemon 已在运行（PID={{ownerPid}}），agents root 为 '{{agentsRoot}}'。日志目录：'{{journalPath}}'。不要删除活跃进程持有的 journal 锁。请先停止现有 daemon 再重试；如果它由系统服务管理，请使用 'crew-daemon stop --profile <name>' 或 'crew-daemon restart --profile <name>'。",
 };
 export function translateDaemon(lang, message) {
     if (lang === "zh")

package/dist/local-executor.js

@@ -9,7 +9,7 @@ import { applyProviderEnv, providerFingerprint } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
-import { toConsoleLines } from "./console.js";
+import { createConsoleFormatter } from "./console-formatter.js";
 import { capMemoryForInject, capWorkLogForInject } from "./prompt.js";
 import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder, stripExternalAnswerMarkers, } from "./external-output.js";
 import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
@@ -300,6 +300,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         let finalText = null;
         let sentViaCrew = false;
         const externalOutput = new ExternalAnswerDecoder();
+        // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
+        const consoleFormatter = createConsoleFormatter();
         const readline = createInterface({ input: child.stdout });
         readline.on("line", (line) => {
             const event = parseLine(line);
@@ -327,7 +329,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             for (const text of decodeExternalOutputEvent(runtime.name, event, externalOutput)) {
                 callbacks.onExternalOutput?.(text);
             }
-            for (const chunk of toConsoleLines(event))
+            for (const chunk of consoleFormatter.format(event))
                 callbacks.onConsole?.(chunk);
         });
         let stderrTail = "";

package/dist/machine-info.js

@@ -103,7 +103,7 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         (dependencies.detectInstalled ?? detectRuntimes)(),
         listAgentHandles(agentsRoot),
     ]);
-    const backend = executionBackendCapability(runtimePlatform);
+    const backend = executionBackendCapability(runtimePlatform, dependencies.jobObjectProbe);
     const executionRuntimes = backend.supported
         ? await (dependencies.detectExecutable ?? detectExecutionRuntimes)(runtimes)
         : [];

package/dist/main.js

@@ -17,6 +17,7 @@ import { formatDaemonLogLine } from "./log-format.js";
 import { applyProfileToEnv, assertProfileAgentsRootUnique, daemonHome, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, } from "./computer-profile.js";
 import { runComputerCommand } from "./computer-cli.js";
 import { runServeLifecycle } from "./serve-lifecycle.js";
+import { formatDaemonStartupError } from "./daemon-startup-error.js";
 async function main() {
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
@@ -79,7 +80,9 @@ async function main() {
     }
     if (cmd === "serve") {
         process.stdout.write(formatDaemonLogLine(`🛰️  crew-daemon v${daemonVersion()} (cli v${cliVersion()}) ${td("resident, connecting to")} ${config.serverUrl} ${td("control plane")}...`) + "\n");
-        const service = serve(config);
+        const service = serve(config, {
+            ...(values.profile === undefined ? {} : { profileName: values.profile }),
+        });
         await runServeLifecycle(service);
         return;
     }
@@ -100,14 +103,16 @@ async function main() {
     process.exit(result.exitCode);
 }
 main().catch((e) => {
-    const message = e instanceof ProfileAgentsRootConflictError
-        ? formatDaemonText(detectDaemonLang(), PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
-            profile: e.profile,
-            conflict: e.conflict,
-            agentsRoot: e.agentsRoot,
-            command: e.command,
-        })
-        : e.message;
+    const lang = detectDaemonLang();
+    const message = formatDaemonStartupError(e, lang)
+        ?? (e instanceof ProfileAgentsRootConflictError
+            ? formatDaemonText(lang, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
+                profile: e.profile,
+                conflict: e.conflict,
+                agentsRoot: e.agentsRoot,
+                command: e.command,
+            })
+            : e.message);
     process.stderr.write(`crew-daemon: ${message}\n`);
     process.exitCode = 1;
 });

package/dist/serve.js

@@ -33,9 +33,9 @@ const ACTIVITY_MAP = {
     checking: "checking", claiming: "claiming", crew: "working", tool: "working",
     tool_result: "working", done: "done", error: "error",
 };
-export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe) {
     const query = new URLSearchParams({ key: machineToken });
-    if (executionBackendCapability(runtimePlatform).supported) {
+    if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
@@ -762,6 +762,7 @@ export function serve(config, opts = {}) {
         await reconcileExecutionJournal(executionJournal, {
             agentsRoot: config.agentsRoot,
             serverUrl: config.serverUrl,
+            ...(opts.profileName === undefined ? {} : { profileName: opts.profileName }),
             log: dslog,
             flush: flushSlog,
             writeStderr: (line) => process.stderr.write(line),

package/dist/unified-diff.js

@@ -0,0 +1,84 @@
+/** 严格、有限的 unified diff 解析器。只有完整文件头 + hunk 才识别,避免误染普通 +/- 日志。 */
+import { CONSOLE_DIFF_ROWS, CONSOLE_ROW_CHARS, } from "./console-payload.js";
+const HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+const clip = (text) => text.length > CONSOLE_ROW_CHARS ? `${text.slice(0, CONSOLE_ROW_CHARS)}…` : text;
+const pathFromHeader = (line) => line.slice(4).split("\t", 1)[0].replace(/^[ab]\//, "");
+export function parseUnifiedDiff(input) {
+    const lines = input.split("\n");
+    const files = [];
+    let additions = 0;
+    let deletions = 0;
+    let cursor = 0;
+    let totalRows = 0;
+    let truncated = false;
+    while (cursor < lines.length) {
+        while (cursor < lines.length && !isFileHeaderPair(lines, cursor))
+            cursor++;
+        if (cursor >= lines.length)
+            break;
+        const oldPath = pathFromHeader(lines[cursor]);
+        const newPath = pathFromHeader(lines[cursor + 1]);
+        const path = newPath === "/dev/null" ? oldPath : newPath;
+        cursor += 2;
+        const rows = [];
+        let sawHunk = false;
+        while (cursor < lines.length && !isFileHeaderPair(lines, cursor)) {
+            const match = lines[cursor].match(HUNK);
+            if (!match) {
+                cursor++;
+                continue;
+            }
+            sawHunk = true;
+            let oldLine = Number(match[1]);
+            let oldRemaining = Number(match[2] ?? 1);
+            let newLine = Number(match[3]);
+            let newRemaining = Number(match[4] ?? 1);
+            cursor++;
+            while (cursor < lines.length && (oldRemaining > 0 || newRemaining > 0)) {
+                const line = lines[cursor];
+                cursor++;
+                if (line === "\")
+                    continue;
+                let row;
+                if (line.startsWith("+")) {
+                    row = { type: "add", oldLine: null, newLine, text: clip(line.slice(1)) };
+                    newLine++;
+                    newRemaining--;
+                    additions++;
+                }
+                else if (line.startsWith("-")) {
+                    row = { type: "delete", oldLine, newLine: null, text: clip(line.slice(1)) };
+                    oldLine++;
+                    oldRemaining--;
+                    deletions++;
+                }
+                else if (line.startsWith(" ")) {
+                    row = { type: "context", oldLine, newLine, text: clip(line.slice(1)) };
+                    oldLine++;
+                    newLine++;
+                    oldRemaining--;
+                    newRemaining--;
+                }
+                else
+                    break;
+                if (totalRows < CONSOLE_DIFF_ROWS) {
+                    rows.push(row);
+                    totalRows++;
+                }
+                else
+                    truncated = true;
+            }
+        }
+        if (sawHunk) {
+            if (truncated && !rows.some((row) => row.type === "omitted"))
+                rows.push({ type: "omitted", oldCount: 1, newCount: 1 });
+            files.push({ path, rows });
+        }
+    }
+    if (!files.length)
+        return null;
+    return { kind: "diff_rows", files, additions, deletions, ...(truncated ? { truncated: true } : {}) };
+}
+function isFileHeaderPair(lines, index) {
+    return lines[index]?.startsWith("--- ") === true && lines[index + 1]?.startsWith("+++ ") === true;
+}

package/dist/win32-job-object.js

@@ -0,0 +1,193 @@
+/**
+ * Windows Job Object 执行后端的 FFI 封装(仅 win32 生效)。
+ *
+ * Node 不暴露 Job Object API,这里用 koffi 直接调 kernel32.dll。koffi 是可选依赖
+ * (optionalDependencies),用 createRequire 惰性同步加载 —— 加载失败/非 win32 一律抛错,
+ * 由上层降级到 fail-closed,不影响 Mac/Linux 路径。
+ *
+ * 关键语义:job 上设 JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE 后,持有 job handle 的进程一旦退出
+ * (含崩溃),内核立即回收 Job 内所有进程 —— 等价于 POSIX「父死子亡 + 进程组整组清理」,且更强。
+ * 因此 job 必须由「离 runtime 最近、崩溃即代表该放弃所有权」的进程(supervisor child)创建并持有。
+ */
+import { createRequire } from "node:module";
+const JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x0000_2000;
+const JOBOBJECT_EXTENDED_LIMIT_INFORMATION = 9;
+const JOBOBJECT_BASIC_ACCOUNTING_INFORMATION = 1;
+const PROCESS_TERMINATE = 0x0001;
+const PROCESS_SET_QUOTA = 0x0100;
+const JOB_ASSIGN_ACCESS = PROCESS_TERMINATE | PROCESS_SET_QUOTA;
+const JOB_EMPTY_POLL_MS = 10;
+// koffi 的 struct 布局/对齐由类型描述自动推导,无需手工塞 padding。
+// size_t/uintptr_t 在 x64/arm64 均为 8 字节,与 SIZE_T/ULONG_PTR 对齐。
+const BASIC_LIMIT_INFORMATION = {
+    PerProcessUserTimeLimit: "int64",
+    PerJobUserTimeLimit: "int64",
+    LimitFlags: "uint32",
+    MinimumWorkingSetSize: "size_t",
+    MaximumWorkingSetSize: "size_t",
+    ActiveProcessLimit: "uint32",
+    Affinity: "uintptr_t",
+    PriorityClass: "uint32",
+    SchedulingClass: "uint32",
+};
+const IO_COUNTERS = {
+    ReadOperationCount: "uint64",
+    WriteOperationCount: "uint64",
+    OtherOperationCount: "uint64",
+    ReadTransferCount: "uint64",
+    WriteTransferCount: "uint64",
+    OtherTransferCount: "uint64",
+};
+let cachedApi = null;
+let loadFailed = false;
+/**
+ * 惰性加载并绑定 kernel32。非 win32 或 koffi 不可用时抛错。结果缓存;失败也缓存(不反复重试)。
+ */
+function loadKernel32() {
+    if (cachedApi !== null)
+        return cachedApi;
+    if (loadFailed)
+        throw new Error("Windows Job Object backend previously failed to load");
+    if (process.platform !== "win32") {
+        loadFailed = true;
+        throw new Error("Windows Job Object backend is only available on win32");
+    }
+    try {
+        cachedApi = bindKernel32();
+        return cachedApi;
+    }
+    catch (error) {
+        loadFailed = true;
+        throw error instanceof Error ? error : new Error(String(error));
+    }
+}
+function bindKernel32() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- koffi 无类型声明,单点收窄。
+    const koffi = createRequire(import.meta.url)("koffi");
+    const lib = koffi.load("kernel32.dll");
+    koffi.struct("JOBOBJECT_BASIC_LIMIT_INFORMATION", BASIC_LIMIT_INFORMATION);
+    koffi.struct("IO_COUNTERS", IO_COUNTERS);
+    koffi.struct("JOBOBJECT_EXTENDED_LIMIT_INFORMATION", {
+        BasicLimitInformation: "JOBOBJECT_BASIC_LIMIT_INFORMATION",
+        IoInfo: "IO_COUNTERS",
+        ProcessMemoryLimit: "size_t",
+        JobMemoryLimit: "size_t",
+        PeakProcessMemoryUsed: "size_t",
+        PeakJobMemoryUsed: "size_t",
+    });
+    koffi.struct("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION", {
+        TotalUserTime: "int64",
+        TotalKernelTime: "int64",
+        ThisPeriodTotalUserTime: "int64",
+        ThisPeriodTotalKernelTime: "int64",
+        TotalPageFaultCount: "uint32",
+        TotalProcesses: "uint32",
+        ActiveProcesses: "uint32",
+        TotalTerminatedProcesses: "uint32",
+    });
+    const CreateJobObjectW = lib.func("void* __stdcall CreateJobObjectW(void* attrs, void* name)");
+    const SetInformationJobObject = lib.func("bool __stdcall SetInformationJobObject(void* job, int cls, void* info, uint32_t len)");
+    const OpenProcess = lib.func("void* __stdcall OpenProcess(uint32_t access, bool inherit, uint32_t pid)");
+    const AssignProcessToJobObject = lib.func("bool __stdcall AssignProcessToJobObject(void* job, void* process)");
+    const TerminateJobObject = lib.func("bool __stdcall TerminateJobObject(void* job, uint32_t code)");
+    const QueryInformationJobObject = lib.func("bool __stdcall QueryInformationJobObject(void* job, int cls, _Out_ void* info, uint32_t len, void* ret)");
+    const CloseHandle = lib.func("bool __stdcall CloseHandle(void* handle)");
+    const GetLastError = lib.func("uint32_t __stdcall GetLastError()");
+    return {
+        createJobObject: () => CreateJobObjectW(null, null),
+        setKillOnClose: (job) => {
+            // 只需把 LimitFlags 置上 KILL_ON_JOB_CLOSE,其余字段留 0。用 Buffer + offsetof 直写,
+            // 规避 koffi.encode 的入参数量怪癖;offset 由 koffi 从结构体推导,x64/arm64 一致。
+            const size = koffi.sizeof("JOBOBJECT_EXTENDED_LIMIT_INFORMATION");
+            const flagsOffset = koffi.offsetof("JOBOBJECT_BASIC_LIMIT_INFORMATION", "LimitFlags");
+            const buffer = Buffer.alloc(size);
+            buffer.writeUInt32LE(JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE, flagsOffset);
+            return SetInformationJobObject(job, JOBOBJECT_EXTENDED_LIMIT_INFORMATION, buffer, size);
+        },
+        openProcess: (access, inherit, pid) => OpenProcess(access, inherit, pid),
+        assignProcessToJob: (job, process) => AssignProcessToJobObject(job, process),
+        terminateJobObject: (job, exitCode) => TerminateJobObject(job, exitCode),
+        queryActiveProcessCount: (job) => {
+            const size = koffi.sizeof("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION");
+            const activeOffset = koffi.offsetof("JOBOBJECT_BASIC_ACCOUNTING_INFORMATION", "ActiveProcesses");
+            const buffer = Buffer.alloc(size);
+            const ok = QueryInformationJobObject(job, JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, buffer, size, null);
+            if (!ok)
+                throw new Error(`QueryInformationJobObject failed (GetLastError=${GetLastError()})`);
+            return buffer.readUInt32LE(activeOffset);
+        },
+        closeHandle: (handle) => CloseHandle(handle),
+        getLastError: () => GetLastError(),
+    };
+}
+/**
+ * 同步探测:能否创建带 KILL_ON_JOB_CLOSE 的 Job Object。用于 backend 能力判定。
+ * 非 win32 / koffi 缺失 / API 调用失败 → false(fail-closed 降级 legacy)。副作用为零(建后即关)。
+ */
+export function isJobObjectSupported() {
+    if (process.platform !== "win32")
+        return false;
+    try {
+        const handle = createKillOnCloseJob();
+        closeJob(handle);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 创建带 KILL_ON_JOB_CLOSE 的 Job Object。失败抛错。 */
+export function createKillOnCloseJob() {
+    const api = loadKernel32();
+    const native = api.createJobObject();
+    if (!native)
+        throw new Error(`CreateJobObjectW failed (GetLastError=${api.getLastError()})`);
+    if (!api.setKillOnClose(native)) {
+        const code = api.getLastError();
+        api.closeHandle(native);
+        throw new Error(`SetInformationJobObject(KILL_ON_JOB_CLOSE) failed (GetLastError=${code})`);
+    }
+    return { native };
+}
+/** 把 pid 对应进程塞进 Job。进程随后 fork 的子孙默认继承 Job(未设 SILENT_BREAKAWAY,禁止逃逸)。 */
+export function assignProcessToJob(handle, pid) {
+    const api = loadKernel32();
+    const process = api.openProcess(JOB_ASSIGN_ACCESS, false, pid);
+    if (!process)
+        throw new Error(`OpenProcess(${pid}) failed (GetLastError=${api.getLastError()})`);
+    try {
+        if (!api.assignProcessToJob(handle.native, process)) {
+            throw new Error(`AssignProcessToJobObject(${pid}) failed (GetLastError=${api.getLastError()})`);
+        }
+    }
+    finally {
+        api.closeHandle(process);
+    }
+}
+/** 一次性杀光 Job 内所有进程(超时/取消/runtime 挂了 supervisor 还在)。 */
+export function terminateJob(handle, exitCode = 1) {
+    const api = loadKernel32();
+    if (!api.terminateJobObject(handle.native, exitCode)) {
+        throw new Error(`TerminateJobObject failed (GetLastError=${api.getLastError()})`);
+    }
+}
+/** 关闭 job handle。若为最后一个引用且设了 KILL_ON_JOB_CLOSE,内核连带杀光 Job 内进程。 */
+export function closeJob(handle) {
+    const api = loadKernel32();
+    api.closeHandle(handle.native);
+}
+/** 当前 Job 内活跃进程数(BasicAccountingInformation.ActiveProcesses)。 */
+export function activeProcessCount(handle) {
+    return loadKernel32().queryActiveProcessCount(handle.native);
+}
+/** 轮询等待 Job 清空(整组退出确认),复用 10ms 节奏。超时抛错。 */
+export async function waitForJobEmpty(handle, timeoutMs, pollMs = JOB_EMPTY_POLL_MS) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        if (activeProcessCount(handle) === 0)
+            return;
+        if (Date.now() >= deadline)
+            throw new Error(`Job Object did not empty within ${timeoutMs}ms`);
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.20",
+  "version": "0.5.22",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -23,6 +23,9 @@
     "zod": "^3.23.0",
     "@nowcrew/cli": "^0.4.6"
   },
+  "optionalDependencies": {
+    "koffi": "^2.9.0"
+  },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.0.0",