@nowcrew/daemon 0.5.20 → 0.5.21

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-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-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/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/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.21",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -21,7 +21,10 @@
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "zod": "^3.23.0",
-    "@nowcrew/cli": "^0.4.6"
+    "@nowcrew/cli": "^0.4.12"
+  },
+  "optionalDependencies": {
+    "koffi": "^2.9.0"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",