autowonder 0.2.154 → 0.2.156

package/README.md

@@ -6,14 +6,16 @@ AutoWonder 本地 agent runtime。安装后启动 daemon，持续轮询本地 as
 
 ```bash
 # Qoder CLI（模型使用 provider model ID；Context Window 使用固定档位）
-npx -y autowonder@0.2.154 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qoder --model qmodel_latest --reasoning-effort medium --context-window 260000
+npx -y autowonder@0.2.156 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qoder --model qmodel_latest --reasoning-effort medium --context-window 260000
 
 # Qoder CLI CN
-npx -y autowonder@0.2.154 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
+npx -y autowonder@0.2.156 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qodercn
 ```
 
 `connect` 会安装当前 npm 包内置的 daemon，并使用页面生成的 WebSocket endpoint、Token 和执行器 ID 建立连接。客户端只支持通过 Qoder 系列 CLI 启动（`qoder` 对应 `qodercli`，`qodercn` 对应 `qodercn`），其他 `--provider` 取值会在启动 daemon 前直接报错拦截并提示 `Unsupported provider`。选择 Qoder 时需要 Node.js 20+；runtime 会在缺少 `qodercli` 时自动通过 npm 安装，并在尚未登录时打开 Qoder 浏览器登录。runtime 会继承当前用户的 HOME、环境变量和 CLI 登录状态。
 
+`connect` 和 `start` 都要求 Qoder CLI / Qoder CLI CN 版本至少为 `1.1.50`。检测到旧版或无法解析的版本时，runtime 会对当前优先选中的用户 CLI 执行内置 `update`，原位升级到最新版并再次强校验；升级失败或升级后仍不满足最低版本时拒绝启动 daemon。所有 Qoder 系列子进程（普通任务、conversation、warm 会话、恢复回退、命令与模型探测）都会强制注入固定的 `QODER_INTEGRATION_ID`，调用方环境不能覆盖该流量归因标识。
+
 `qodercn` 是国内版 Qoder CLI。runtime 会在缺少 `qodercn` 时自动把 `@qodercn-ai/qoderclicn` 安装到 `~/.autowonder/qoder-cn-cli`，并在尚未登录时打开浏览器登录。它使用自己的配置根（`QODERCN_CONFIG_DIR`，默认 `~/.qoder-cn`），与国际版 `qoder` 不共享可执行文件、凭证和会话。可用 `AUTOWONDER_QODERCN_CLI` 指定自定义可执行文件路径。
 
 Qoder 的 Context Window 只能使用 `1000000`、`400000` 或 `260000`，Reasoning Effort 只能使用 `none`、`low`、`medium`、`high`、`xhigh` 或 `max`。`--model` 不再校验固定白名单：取值经 `AUTOWONDER_MODEL` 原样透传给 Qoder CLI，因此服务端上线新模型无需升级本客户端。建议直接复制 AutoWonder 执行器页面生成的命令，避免把模型展示名称误当成 provider model ID。
@@ -26,6 +28,28 @@ daemon 还会响应服务端的 `CONVERSATION_COMMANDS_PROBE` 帧，用独立会
 
 `connect` 支持 `--workspace-root <path>` 指定 dispatch 仓库与任务工作区所在目录（默认 `~/autowonder_workspaces`）。该参数会转发给 daemon，等价于设置 `AUTOWONDER_WORKSPACE_ROOT` 环境变量，适合把工作区放在非默认路径的执行机上（如 Windows 的 `D:\autowonder`）。
 
+## 工作区保留与 Git 对象复用
+
+daemon 默认启用本地工作区 GC：启动 30 秒后开始检查，之后每小时执行有限量的后台清理。非会话任务仅在终态且最后活动时间超过所配置的任务 TTL（默认 72 小时）后才符合清理条件；会话目录仅在最后活动时间超过所配置的会话 TTL（默认 720 小时）后才符合条件。清理的单位是整个 attempt capsule 或整个 conversation capsule，不会只删除其中部分文件。未知或格式异常、非终态（包括 uploading）、仍在运行、由恢复流程持有、结果仍待确认，或结果状态查询失败的 capsule 都会保留。
+
+磁盘使用率达到 85% 或可用空间低于 10 GiB 时进入压力模式，恢复目标是使用率不高于 75% 且可用空间至少 15 GiB。压力只会调整有限量清理工作的调度和顺序；它不会放宽所配置的任务/会话 TTL（默认 72/720 小时），也不会让较新的 capsule 提前被删除。
+
+相关环境变量及默认值如下：
+
+- `AUTOWONDER_WORKSPACE_GC_ENABLED=true`
+- `AUTOWONDER_WORKSPACE_GC_INITIAL_DELAY=30s`
+- `AUTOWONDER_WORKSPACE_GC_INTERVAL=1h`
+- `AUTOWONDER_WORKSPACE_GC_TASK_TTL=72h`
+- `AUTOWONDER_WORKSPACE_GC_CONVERSATION_TTL=720h`
+- `AUTOWONDER_WORKSPACE_GC_HIGH_WATERMARK_PERCENT=85`
+- `AUTOWONDER_WORKSPACE_GC_LOW_WATERMARK_PERCENT=75`
+- `AUTOWONDER_WORKSPACE_GC_MIN_FREE_BYTES=10737418240`（10 GiB）
+- `AUTOWONDER_WORKSPACE_GC_TARGET_FREE_BYTES=16106127360`（15 GiB）
+
+将 `AUTOWONDER_WORKSPACE_GC_ENABLED` 设为 `false` 只会禁用自主 GC；服务端下发的 `WORKITEM_WORKSPACE_CLEANUP` 清理仍按原有生命周期执行。
+
+`~/autowonder_workspaces`（可由 `--workspace-root` 或 `AUTOWONDER_WORKSPACE_ROOT` 修改）保存每个任务独立的工作文件和 checkout/worktree；`~/.autowonder/git-object-cache/v1` 保存可供多个任务复用 Git 历史对象的本地 bare mirror。每个任务仍会得到所请求准确 commit 的独立工作区。已缓存的固定 commit 可以不查询远端；允许联网时，`HEAD`、branch 或 tag 等可移动 ref 会在每次 materialization 时向远端解析为准确 commit，仅在 mirror 缺少该对象时 fetch。缓存优化失败时，只有其临时目录已经完成可验证的干净回滚才会回退到原有的远端完整 clone 流程；若无法证明干净回滚，则会保留现场并返回错误，不进入回退。任何路径都不会发布不完整的目标目录；已经存在的任务仓库只做校验，不会被 fetch、reset、clean、checkout 或覆盖。本版本不会自动淘汰 Git 对象缓存，工作区 GC 也不会删除该缓存。
+
 ## 自动更新
 
 安装首个支持自动更新的正式版本后，daemon 会直接查询 npm 的 `autowonder/latest`。首次检查会随机分散在启动后的 30～90 秒，之后约每 5 分钟检查一次并加入随机抖动；npm 临时错误会指数退避，HTTP 429/503 的 `Retry-After` 会被遵循。发现更高的稳定版本时，它会在后台下载 npm tarball，校验 SHA-512 SRI、包版本和平台二进制；只有在没有运行/恢复任务且结果 outbox 已收到服务端确认时，才会暂停接单、原子切换二进制并自动重启。启动失败会恢复上一个二进制。
@@ -44,6 +68,10 @@ npx -y autowonder@latest connect ...
 
 候选版本缓存在 `~/.autowonder/updates/`；当前二进制和单个回滚副本位于 `~/.autowonder/bin/`。`GET /health` 会返回 `daemonVersion`、`updateState`、`updateTarget` 和 `updateError`。
 
+daemon 建立连接时和每次心跳定时检查时发出的 `HEARTBEAT` 帧都带上 `version` 字段，取值为该二进制构建时注入的发布版本号（`currentReleaseIdentity().Version`，与 `--self-check` 报告的版本同源）；版本为空时该字段不出现在帧里。服务端据此记录每台执行机实际运行的客户端版本并在执行器列表展示，为后续客户端批量升级提供数据基础。对执行机用户无新增参数或环境变量。
+
+同一批 `HEARTBEAT` 帧还带上进程级固定的 `startedAt`（重连不重置）与继承自 re-exec 的 `restartRequestId`，并在能力位里声明 `EXECUTOR_RESTART_V1`（Windows 不声明）；接入自动更新的 daemon 额外声明 `EXECUTOR_UPDATE_RESTART_V1`。服务端可据此下发 `EXECUTOR_RESTART`（带 `executorId`、`requestId`、ISO UTC `issuedAt` 与布尔 `update`）。本机只接受 `executorId` 与自身一致、未过期且未处理过的请求，不接收任何远端 shell 命令、可执行路径或下载地址，并以 `EXECUTOR_RESTART_RESULT`（`UPDATING` / `RESTARTING` / `FAILED`）回执，真正是否成功以下一次心跳为准。重启走既有的接单闸门：有运行中任务或结果 outbox 未确认可读时不重启，re-exec 失败会重新开放接单；`update=true` 复用既有的 registry、完整性校验、候选 self-check、安装事务与回滚，仅标准安装的正式版支持远端拉取新版本，已是最新版的请求仍会重启，且该操作不应用平台上保存的启动配置改动。对执行机用户同样无新增参数或环境变量。
+
 ## 发布构建
 
 `npm run build` 和发布脚本只接受没有已跟踪或未跟踪改动的 Git worktree。脚本会把准确的 release commit 克隆到仓库外的 detached checkout，再从该目录构建六个平台（darwin/linux/windows × amd64/arm64）的 daemon。
@@ -64,7 +92,7 @@ mv "$queue/.assignment.tmp" "$queue/assignment.json"
 也可以直接提交到本地 API：
 
 ```bash
-npx -y autowonder@0.2.154 dispatch ./assignment.json
+npx -y autowonder@0.2.156 dispatch ./assignment.json
 ```
 
 ## 上传工单附件
@@ -72,7 +100,7 @@ npx -y autowonder@0.2.154 dispatch ./assignment.json
 把本地需求/设计文档直接上传到工单，避免在会话里传递大文件：
 
 ```bash
-npx -y autowonder@0.2.154 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.2.156 workitem upload --server-url <autowonder-server-url> --workitem-id <id> --file <filepath-1> --file <filepath-2> --json
 ```
 
 上传令牌通过 MCP 工具 `autowonder.workitem_cli_upload_token` 签发，经 `--token` 或 `AUTOWONDER_UPLOAD_TOKEN` 环境变量传入。`--file` 可重复指定多个文件；`--json` 输出机器可读结果。失败时按错误类型返回不同退出码（401→3、403→4、404→5、409→6、413→7、其他 4xx→8、网络/重定向→9）。
@@ -82,7 +110,7 @@ npx -y autowonder@0.2.154 workitem upload --server-url <autowonder-server-url> -
 把工单上已有的需求/设计文档下载到本地目录，再用本地文件工具阅读，避免把大文件或二进制附件搬进会话上下文：
 
 ```bash
-npx -y autowonder@0.2.154 workitem download --server-url <autowonder-server-url> --workitem-id <id> --file <name-or-id> --output-dir <dir> --json
+npx -y autowonder@0.2.156 workitem download --server-url <autowonder-server-url> --workitem-id <id> --file <name-or-id> --output-dir <dir> --json
 ```
 
 下载令牌通过 MCP 工具 `autowonder.workitem_cli_download_token` 签发（与上传令牌相互独立），经 `--token` 或 `AUTOWONDER_DOWNLOAD_TOKEN` 环境变量传入。`--file` 可重复指定文档名或 artifact id，省略则下载该工单的全部附件；`--output-dir` 默认为当前目录；`--json` 输出机器可读结果，含每个文件的 `id`、`name`、`path`、`size`。退出码约定与 `workitem upload` 相同（401→3、403→4、404→5、409→6、413→7、其他 4xx→8、网络/重定向→9）。
@@ -92,7 +120,7 @@ npx -y autowonder@0.2.154 workitem download --server-url <autowonder-server-url>
 把需求/设计文档上传到 7x24 定时任务，用法与工单附件一致（同一套上传令牌与预检规则）：
 
 ```bash
-npx -y autowonder@0.2.154 scheduled-task upload --server-url <autowonder-server-url> --scheduled-task-id <id> --file <filepath-1> --file <filepath-2> --json
+npx -y autowonder@0.2.156 scheduled-task upload --server-url <autowonder-server-url> --scheduled-task-id <id> --file <filepath-1> --file <filepath-2> --json
 ```
 
 上传令牌同样通过 `autowonder.workitem_cli_upload_token` 签发（令牌为用户级，对当前可修改的任意定时任务生效），经 `--token` 或 `AUTOWONDER_UPLOAD_TOKEN` 传入；退出码约定与 `workitem upload` 相同。
@@ -100,8 +128,8 @@ npx -y autowonder@0.2.154 scheduled-task upload --server-url <autowonder-server-
 ## 管理 daemon
 
 ```bash
-npx -y autowonder@0.2.154 status
-npx -y autowonder@0.2.154 stop
+npx -y autowonder@0.2.156 status
+npx -y autowonder@0.2.156 stop
 ```
 
 默认 API 是 `http://127.0.0.1:34989`，日志位于 `~/.autowonder/daemon.log`。npm 包不包含任何 agent、MCP 或服务端凭证。
@@ -109,7 +137,7 @@ npx -y autowonder@0.2.154 stop
 ## 调试
 
 ```bash
-npx -y autowonder@0.2.154 connect ... --debug
+npx -y autowonder@0.2.156 connect ... --debug
 ```
 
 `--debug` 会让 CLI 以 `AUTOWONDER_DEBUG=1` 启动 daemon，把完整的 daemon 与 agent 活动（runtime 事件流、provider 事件解码、重试退避与会话门等待、空闲时的阻塞点）同时输出到控制台和会话调试日志。调试日志不做脱敏，仅用于本机排障；不传 `--debug` 时该环境变量不会注入。

package/bin/cli.js

@@ -508,6 +508,7 @@ async function cmdStart(args) {
     process.exit(1);
   }
   assertSupportedProvider(provider);
+  if (!(await ensureQoderReady(provider))) process.exit(1);
 
   const installed = await installBinary();
   if (!installed) process.exit(1);

package/bin/process-tree-runner.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+"use strict";
+
+// Unix process-tree runner. Windows uses windows-job-runner.ps1 so the target
+// is created suspended, assigned to a kill-on-close Job Object, then resumed.
+const { spawn } = require("child_process");
+
+const timeout = Number.parseInt(process.argv[2], 10);
+const executable = process.argv[3];
+const args = JSON.parse(process.argv[4] || "[]");
+const child = spawn(executable, args, {
+  env: process.env,
+  stdio: "inherit",
+  shell: false,
+  detached: true,
+});
+
+let timedOut = false;
+let terminated = false;
+function terminateTree() {
+  if (terminated || !child.pid) return;
+  try { process.kill(-child.pid, "SIGKILL"); } catch {}
+  terminated = true;
+}
+
+const timer = setTimeout(() => {
+  timedOut = true;
+  terminateTree();
+}, timeout);
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    clearTimeout(timer);
+    terminateTree();
+    process.exit(128);
+  });
+}
+
+child.on("error", (err) => {
+  clearTimeout(timer);
+  terminateTree();
+  console.error(err.message);
+  process.exit(127);
+});
+child.on("exit", (code, signal) => {
+  clearTimeout(timer);
+  terminateTree();
+  if (timedOut) process.exit(124);
+  if (Number.isInteger(code)) process.exit(code);
+  console.error(`process terminated by ${signal || "unknown signal"}`);
+  process.exit(1);
+});

package/bin/qoder-bootstrap.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const { spawnSync } = require("child_process");
+const crypto = require("crypto");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
@@ -8,6 +9,29 @@ const path = require("path");
 const { ensureDir, error, findOnPath, log, resolveUserPath } = require("./shared");
 
 const IS_WIN32 = process.platform === "win32";
+const QODER_INTEGRATION_ID_ENV = "QODER_INTEGRATION_ID";
+const LEGACY_QODER_HOST_SERVICE_NAME_ENV = "QODER_HOST_SERVICE_NAME";
+// AutoWonder's permanent, unique service identity for traffic reported to
+// Qoder. DO NOT CHANGE this UUID after publication: changing it would split
+// historical and future attribution. It is not configurable or regenerated.
+const QODER_INTEGRATION_ID = "5b5d9168-09e0-4b8a-92f5-2ee7cd817fed";
+const QODER_MINIMUM_VERSION = [1, 1, 50];
+const QODER_LOCK_MAX_PID = 2147483647;
+const QODER_VERSION_LINE_RE = /^(?:(?:qodercli|qodercn|qoder(?: cli(?: cn)?)?)\s+)?v?(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9][0-9]*|[0-9]*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\s+\([^)]*\))?$/i;
+const PROCESS_TREE_RUNNER = path.join(__dirname, "process-tree-runner.js");
+const WINDOWS_JOB_RUNNER = path.join(__dirname, "windows-job-runner.ps1");
+
+function spawnSyncWithTreeTimeout(executable, args, options) {
+  const timeout = options.timeout;
+  const runnerOptions = { ...options, timeout: timeout + 30000 };
+  if (IS_WIN32) {
+    const powershell = path.join(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+    const encodedArgs = Buffer.from(JSON.stringify(args), "utf8").toString("base64");
+    return spawnSync(powershell, ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-File",
+      WINDOWS_JOB_RUNNER, "-TimeoutMs", String(timeout), "-Executable", executable, "-ArgsBase64", encodedArgs], runnerOptions);
+  }
+  return spawnSync(process.execPath, [PROCESS_TREE_RUNNER, String(timeout), executable, JSON.stringify(args)], runnerOptions);
+}
 
 // qoder and qodercn are two distinct provider identities that share the same
 // bootstrap flow. Each identity keeps its own executable, npm package, managed
@@ -68,11 +92,35 @@ function isQoderFamilyProvider(provider) {
 // Quotes one argument for cmd.exe. Paths containing spaces must stay a single
 // token when a .cmd shim is launched through ComSpec.
 function quoteWindowsArg(arg) {
-  if (arg && !/[\s"]/.test(arg)) return arg;
-  return `"${String(arg).replace(/"/g, '\\"')}"`;
+  const value = String(arg);
+  return `"${value.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\+)$/g, "$1$1")}"`;
+}
+
+function windowsQoderShimInvocation(executable, args, baseEnv) {
+  const env = {};
+  for (const [key, value] of Object.entries(baseEnv)) {
+    if (!key.toLowerCase().startsWith("autowonder_qoder_shim_path")) env[key] = value;
+  }
+  env.AUTOWONDER_QODER_SHIM_PATH = executable;
+  // cmd expands environment variables once. Keeping the executable in an env
+  // value prevents %, &, ^ and other legal path characters from becoming
+  // command source; the surrounding quotes keep the expanded path one token.
+  const inner = [`"%AUTOWONDER_QODER_SHIM_PATH%"`, ...args.map(quoteWindowsArg)].join(" ");
+  return { env, command: `"${inner}"` };
+}
+
+function qoderChildEnv(extra = {}) {
+  const env = { ...process.env, ...extra };
+  for (const key of Object.keys(env)) {
+    if (key.toLowerCase() === LEGACY_QODER_HOST_SERVICE_NAME_ENV.toLowerCase()
+      || key.toLowerCase() === QODER_INTEGRATION_ID_ENV.toLowerCase()) delete env[key];
+  }
+  env[QODER_INTEGRATION_ID_ENV] = QODER_INTEGRATION_ID;
+  return env;
 }
 
 function spawnQoderSync(executable, args, options = {}) {
+  const env = qoderChildEnv(options.env);
   // npm exposes package binaries as .cmd shims on Windows. CreateProcess
   // cannot execute those shims directly, but shell:true would join the
   // executable and its arguments with bare spaces and shred any path that
@@ -81,10 +129,19 @@ function spawnQoderSync(executable, args, options = {}) {
   // plain argument array with no shell involved.
   if (IS_WIN32 && /\.(cmd|bat)$/i.test(executable)) {
     const comspec = process.env.ComSpec || "cmd.exe";
-    const command = [quoteWindowsArg(executable), ...args.map(quoteWindowsArg)].join(" ");
-    return spawnSync(comspec, ["/d", "/s", "/c", command], options);
+    const invocation = windowsQoderShimInvocation(executable, args, env);
+    const spawnArgs = ["/d", "/v:off", "/s", "/c", invocation.command];
+    if (options.treeTimeout) {
+      const { treeTimeout: _, ...treeOptions } = options;
+      return spawnSyncWithTreeTimeout(comspec, spawnArgs, { ...treeOptions, env: invocation.env });
+    }
+    return spawnSync(comspec, spawnArgs, { ...options, env: invocation.env });
+  }
+  if (options.treeTimeout) {
+    const { treeTimeout: _, ...treeOptions } = options;
+    return spawnSyncWithTreeTimeout(executable, args, { ...treeOptions, env, shell: false });
   }
-  return spawnSync(executable, args, { ...options, shell: false });
+  return spawnSync(executable, args, { ...options, env, shell: false });
 }
 
 // Roots that hold user-level installers on Windows. Kept env-driven so the
@@ -220,18 +277,49 @@ function findQoderExecutable(provider) {
   return "";
 }
 
-function installQoderCLI(provider) {
+function managedQoderExecutable(profile) {
+  const binName = IS_WIN32 ? profile.windowsShimName : profile.managedBinName;
+  return path.join(qoderPaths(profile).managedDir, "node_modules", ".bin", binName);
+}
+
+function installQoderCLI(provider, options = {}) {
+  const profile = QODER_FAMILY_PROFILES[provider];
+  if (options.lockHeld) return installQoderCLIUnlocked(provider);
+  const result = withQoderUpdateLock(managedQoderExecutable(profile), () => {
+    if (options.skipIfPresent) {
+      const existing = findQoderExecutable(provider);
+      if (existing) return existing;
+    }
+    return installQoderCLIUnlocked(provider);
+  });
+  return result || "";
+}
+
+function installQoderCLIUnlocked(provider) {
   const profile = QODER_FAMILY_PROFILES[provider];
   const managedDir = qoderPaths(profile).managedDir;
   log(`${profile.displayName} is not installed. Installing ${profile.npmPackage}...`);
   const args = [
     "install", "--prefix", managedDir, profile.npmPackage, "--no-audit", "--no-fund",
   ];
+  const installDeadline = Date.now() + 5 * 60 * 1000;
   // npm is a .cmd shim on Windows. When launched by npx, npm_execpath points
   // at npm-cli.js, which Node can execute directly without cmd.exe quoting.
-  const runNpm = (npmArgs) => IS_WIN32 && process.env.npm_execpath
-    ? spawnSync(process.execPath, [process.env.npm_execpath, ...npmArgs], { stdio: "inherit" })
-    : spawnSync("npm", npmArgs, { stdio: "inherit" });
+  const installEnv = qoderChildEnv();
+  const npmExecPath = IS_WIN32 ? process.env.npm_execpath : "";
+  const npmShim = IS_WIN32 && !npmExecPath ? findOnPath("npm.cmd") : "";
+  const npmExecutable = IS_WIN32 && !npmExecPath && !npmShim ? findOnPath("npm.exe") : "";
+  if (IS_WIN32 && !npmExecPath && !npmShim && !npmExecutable) {
+    error(`Failed to install ${profile.displayName}: neither npm.cmd nor npm.exe was found on PATH and npm_execpath is not set.`);
+    return "";
+  }
+  const runNpm = (npmArgs) => {
+    const common = { env: installEnv, stdio: "inherit", timeout: Math.max(1, installDeadline - Date.now()) };
+    if (npmExecPath) return spawnSyncWithTreeTimeout(process.execPath, [npmExecPath, ...npmArgs], common);
+    if (npmShim) return spawnQoderSync(npmShim, npmArgs, { ...common, treeTimeout: true });
+    if (npmExecutable) return spawnSyncWithTreeTimeout(npmExecutable, npmArgs, common);
+    return spawnSyncWithTreeTimeout("npm", npmArgs, common);
+  };
   let result = runNpm(args);
   if (result.status !== 0 && IS_WIN32) {
     log(`Default npm registry failed; retrying ${profile.displayName} installation with npmmirror...`);
@@ -250,22 +338,261 @@ function installQoderCLI(provider) {
 const MACHINE_ID_REL_PATH = path.join(".auth", "machine_id");
 const CREDENTIAL_REL_PATH = path.join(".auth", "user");
 
-// The version is captured for diagnostics and identity comparison only. No
-// control-flow decision anywhere in this module reads it.
-function qoderBinaryVersion(executable) {
+function qoderBinaryVersion(executable, options = {}) {
+  if ((path.isAbsolute(executable) || executable.includes(path.sep)) && !fs.existsSync(executable)) return "missing";
   const result = spawnQoderSync(executable, ["--version"], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
-    timeout: 20000,
+    timeout: options.timeout || 20000,
+    treeTimeout: true,
   });
   // "missing" means the file itself is absent; "unknown" means the file is
   // there but produced no version, so the two failure classes never collapse
   // into one misleading answer.
   if (result.error && result.error.code === "ENOENT") return "missing";
-  // stdout wins so a warning on stderr cannot masquerade as the version and
-  // make the identity comparison see a change that did not happen.
-  const firstLine = (stream) => (stream || "").split(/\r?\n/).map((line) => line.trim()).find(Boolean);
-  return firstLine(result.stdout) || firstLine(result.stderr) || "unknown";
+  if (result.status !== 0) return "unknown";
+  // Accept only an unambiguous Qoder version line. Runtime warnings and update
+  // banners often contain unrelated/newer semvers and must never satisfy the
+  // minimum gate for an old executable.
+  return qoderVersionLine(`${result.stdout || ""}\n${result.stderr || ""}`) || "unknown";
+}
+
+function qoderVersionLine(output) {
+  const matches = String(output || "").split(/\r?\n/).map((line) => line.trim()).filter((line) =>
+    QODER_VERSION_LINE_RE.test(line));
+  return matches.length === 1 ? matches[0] : "";
+}
+
+function qoderVersionMeetsMinimum(output) {
+  const line = qoderVersionLine(output);
+  if (!line) return false;
+  const match = line.match(QODER_VERSION_LINE_RE);
+  const actual = match.slice(1, 4).map((part) => Number.parseInt(part, 10));
+  for (let i = 0; i < QODER_MINIMUM_VERSION.length; i += 1) {
+    if (actual[i] > QODER_MINIMUM_VERSION[i]) return true;
+    if (actual[i] < QODER_MINIMUM_VERSION[i]) return false;
+  }
+  // A prerelease of 1.1.50 is lower than the released minimum.
+  return !match[4];
+}
+
+function qoderUpdateLockPaths(executable) {
+  let lexical = path.resolve(executable);
+  if (IS_WIN32) lexical = lexical.toLowerCase();
+  const keys = [lexical];
+  try {
+    let resolved = fs.realpathSync.native(lexical);
+    if (IS_WIN32) resolved = resolved.toLowerCase();
+    if (resolved !== lexical) keys.push(resolved);
+  } catch { /* the stable lexical key protects installation before the shim exists */ }
+  return keys.map((key) => {
+    const digest = crypto.createHash("sha256").update(key).digest("hex");
+    return path.join(os.homedir(), ".autowonder", "locks", `autowonder-qoder-update-${digest}.lock`);
+  }).sort();
+}
+
+function qoderOwnerState(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return "unknown";
+  try { process.kill(pid, 0); return "alive"; }
+  catch (err) {
+    if (err && err.code === "ESRCH") return "dead";
+    return "unknown";
+  }
+}
+
+function qoderLockArtifactError(kind, artifact) {
+  const err = new Error(`Qoder update ${kind} ${artifact} is not a regular file; remove it manually only after confirming no updater is running.`);
+  err.code = "AUTOWONDER_QODER_LOCK_NOT_REGULAR";
+  return err;
+}
+
+function qoderLockTickets(lockPath) {
+  let maximum = 0n;
+  const tickets = [];
+  for (const name of fs.readdirSync(lockPath)) {
+    if (!name.endsWith(".ticket")) continue;
+    const artifact = path.join(lockPath, name);
+    let info;
+    try { info = fs.lstatSync(artifact); }
+    catch (err) { if (err && err.code === "ENOENT") continue; throw err; }
+    if (!info.isFile()) throw qoderLockArtifactError("ticket", artifact);
+    const match = /^(\d{20})-([1-9]\d*)-([0-9a-f]{32})\.ticket$/.exec(name);
+    if (!match) throw new Error(`Qoder update ticket ${artifact} is malformed; remove it manually only after confirming no updater is running.`);
+    const sequence = BigInt(match[1]);
+    if (sequence > maximum) maximum = sequence;
+    tickets.push(artifact);
+  }
+  tickets.sort();
+  return { tickets, maximum };
+}
+
+function writeQoderLockTicket(lockPath, sequence, owner) {
+  const name = `${String(sequence).padStart(20, "0")}-${owner.pid}-${owner.token}.ticket`;
+  const temporary = path.join(lockPath, `.${name}.tmp`);
+  const ticket = path.join(lockPath, name);
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(owner), { mode: 0o600 });
+    fs.renameSync(temporary, ticket);
+  }
+  catch (err) {
+    try { fs.rmSync(temporary, { force: true }); } catch { /* preserve the publication error */ }
+    throw err;
+  }
+  return ticket;
+}
+
+function writeQoderChoosingMarker(lockPath, owner) {
+  const marker = path.join(lockPath, `choosing-${owner.pid}-${owner.token}`);
+  try { fs.writeFileSync(marker, JSON.stringify(owner), { mode: 0o600, flag: "wx" }); }
+  catch (err) {
+    try { fs.rmSync(marker, { force: true }); } catch { /* preserve the creation error */ }
+    throw err;
+  }
+  return marker;
+}
+
+function qoderChoosingMarkers(lockPath) {
+  const markers = [];
+  for (const name of fs.readdirSync(lockPath)) {
+    if (!name.startsWith("choosing-")) continue;
+    const marker = path.join(lockPath, name);
+    let info;
+    try { info = fs.lstatSync(marker); }
+    catch (err) { if (err && err.code === "ENOENT") continue; throw err; }
+    if (!info.isFile()) throw qoderLockArtifactError("choosing marker", marker);
+    markers.push(marker);
+  }
+  return markers;
+}
+
+function removeDeadQoderChoosingMarkers(markers) {
+  for (const marker of markers) {
+    const match = /^choosing-([1-9]\d*)-([0-9a-f]{32})$/.exec(path.basename(marker));
+    if (!match) throw new Error(`Qoder update choosing marker ${marker} is malformed; remove it manually only after confirming no updater is running.`);
+    const pid = Number.parseInt(match[1], 10);
+    if (!Number.isSafeInteger(pid) || pid <= 0 || pid > QODER_LOCK_MAX_PID) throw new Error(`Qoder update choosing marker ${marker} has an unsupported owner; remove it manually only after confirming no updater is running.`);
+    if (qoderOwnerState(pid) === "dead") fs.rmSync(marker, { force: true });
+  }
+}
+
+function validateQoderLockTickets(tickets) {
+  for (const ticket of tickets) {
+    const match = /^(\d{20})-([1-9]\d*)-([0-9a-f]{32})\.ticket$/.exec(path.basename(ticket));
+    const pid = match ? Number.parseInt(match[2], 10) : 0;
+    if (!match) {
+      throw new Error(`Qoder update ticket ${ticket} is corrupt; remove it manually only after confirming no updater is running.`);
+    }
+    if (!Number.isSafeInteger(pid) || pid <= 0 || pid > QODER_LOCK_MAX_PID) {
+      throw new Error(`Qoder update ticket ${ticket} has an unsupported owner; remove it manually only after confirming no updater is running.`);
+    }
+    const state = qoderOwnerState(pid);
+    if (state === "dead") {
+      let age = Infinity;
+      try {
+        const info = fs.lstatSync(ticket);
+        if (!info.isFile()) throw qoderLockArtifactError("ticket", ticket);
+        age = Date.now() - info.mtimeMs;
+      }
+      catch (err) { if (err && err.code === "ENOENT") continue; throw err; }
+      // Avoid mistaking the normal exit-before-finally micro-window for a
+      // crashed owner. The ticket still blocks entry throughout this grace.
+      if (age < 1000) continue;
+    }
+    if (state !== "alive") {
+      throw new Error(`Qoder update ticket ${ticket} has ${state} owner pid ${pid}; refusing automatic recovery while an updater may survive; remove it manually only after confirming no updater is running.`);
+    }
+  }
+}
+
+function withQoderUpdateLock(executable, fn) {
+  const lockPaths = qoderUpdateLockPaths(executable);
+  fs.mkdirSync(path.dirname(lockPaths[0]), { recursive: true, mode: 0o700 });
+  const deadline = Date.now() + 15 * 60 * 1000;
+  const owner = { pid: process.pid, token: crypto.randomBytes(16).toString("hex") };
+  const acquired = [];
+  let failure = null;
+  try {
+    for (const lockPath of lockPaths) {
+      fs.mkdirSync(lockPath, { recursive: true, mode: 0o700 });
+      const plannedChoosing = path.join(lockPath, `choosing-${owner.pid}-${owner.token}`);
+      acquired.push(plannedChoosing);
+      const choosing = writeQoderChoosingMarker(lockPath, owner);
+      let snapshot = qoderLockTickets(lockPath);
+      validateQoderLockTickets(snapshot.tickets);
+      if (snapshot.maximum >= 18446744073709551615n) {
+        throw new Error(`Qoder update lock sequence exhausted at ${lockPath}`);
+      }
+      const plannedTicketName = `${String(snapshot.maximum + 1n).padStart(20, "0")}-${owner.pid}-${owner.token}.ticket`;
+      acquired.push(path.join(lockPath, `.${plannedTicketName}.tmp`));
+      const ticket = writeQoderLockTicket(lockPath, snapshot.maximum + 1n, owner);
+      acquired.push(ticket);
+      fs.rmSync(choosing, { force: true });
+      for (;;) {
+        let markers = qoderChoosingMarkers(lockPath);
+        removeDeadQoderChoosingMarkers(markers);
+        markers = qoderChoosingMarkers(lockPath);
+        snapshot = qoderLockTickets(lockPath);
+        validateQoderLockTickets(snapshot.tickets);
+        snapshot = qoderLockTickets(lockPath);
+        if (markers.length === 0 && snapshot.tickets[0] === ticket) break;
+        if (Date.now() >= deadline) {
+          error(`Timed out waiting for another AutoWonder process to finish updating ${executable} (lock queue ${lockPath}).`);
+          return null;
+        }
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+      }
+    }
+    return fn();
+  }
+  catch (err) {
+    failure = err;
+    throw err;
+  }
+  finally {
+    const cleanupErrors = [];
+    for (const ticket of acquired.reverse()) {
+      try { fs.rmSync(ticket, { force: true }); } catch (err) { cleanupErrors.push(err); }
+    }
+    if (cleanupErrors.length) {
+      if (failure) failure.cleanupErrors = cleanupErrors;
+      else throw new AggregateError(cleanupErrors, "failed to clean Qoder update lock artifacts");
+    }
+  }
+}
+
+function ensureMinimumQoderVersion(profile, provider, executable) {
+  const result = withQoderUpdateLock(executable, () => ensureMinimumQoderVersionLocked(profile, provider, executable));
+  return result || { ok: false, version: "unknown", executable };
+}
+
+function ensureMinimumQoderVersionLocked(profile, provider, executable) {
+  let version = qoderBinaryVersion(executable);
+  if (qoderVersionMeetsMinimum(version)) return { ok: true, version };
+
+  log(`${profile.displayName} ${version} is older than required version 1.1.50 (or could not be parsed). Updating the current installation to latest...`);
+  const update = spawnQoderSync(executable, ["update"], { stdio: "inherit", timeout: 5 * 60 * 1000, treeTimeout: true });
+  if (update.status !== 0) {
+    const managedDir = qoderPaths(profile).managedDir;
+    if (executable.startsWith(`${managedDir}${path.sep}`)) {
+      const reinstalled = installQoderCLI(provider, { lockHeld: true });
+      if (reinstalled) {
+        executable = reinstalled;
+        version = qoderBinaryVersion(executable);
+        if (qoderVersionMeetsMinimum(version)) return { ok: true, version, executable };
+      }
+    }
+    const detail = update.error?.message || (update.signal ? `signal ${update.signal}` : `exit status ${update.status}`);
+    error(`${profile.displayName} requires version 1.1.50 or newer, but updating ${executable} failed: ${detail}`);
+    return { ok: false, version, executable };
+  }
+
+  version = qoderBinaryVersion(executable);
+  if (!qoderVersionMeetsMinimum(version)) {
+    error(`${profile.displayName} requires version 1.1.50 or newer, but ${executable} reports ${version} after updating to latest.`);
+    return { ok: false, version, executable };
+  }
+  log(`${profile.displayName} updated in place to ${version}.`);
+  return { ok: true, version, executable };
 }
 
 // A missing or unreadable record means "no history", never a bootstrap failure.
@@ -348,6 +675,7 @@ function probeQoderAuth(profile, executable, configRoot, options = {}) {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: 20000,
+    treeTimeout: true,
     env: { ...process.env, [profile.configDirEnv]: configRoot },
   });
   const probe = {
@@ -556,6 +884,10 @@ async function loginThenWait(profile, executable, configRoot, options) {
 function finishQoderReady(profile, provider, executable, version, configRoot, rootSource) {
   writeQoderState(profile, provider, { resolvedPath: executable, version, configRoot });
   process.env[profile.envVar] = executable;
+  process.env[QODER_INTEGRATION_ID_ENV] = QODER_INTEGRATION_ID;
+  for (const key of Object.keys(process.env)) {
+    if (key.toLowerCase() === LEGACY_QODER_HOST_SERVICE_NAME_ENV.toLowerCase()) delete process.env[key];
+  }
   const executableDir = path.dirname(executable);
   const pathEntries = (process.env.PATH || "").split(path.delimiter);
   if (!pathEntries.includes(executableDir)) {
@@ -566,7 +898,6 @@ function finishQoderReady(profile, provider, executable, version, configRoot, ro
 }
 
 async function ensureQoderReady(provider, options = {}) {
-  if (process.env.AUTOWONDER_SKIP_QODER_BOOTSTRAP === "1") return true;
   const profile = QODER_FAMILY_PROFILES[provider];
   const inspectOptions = { debug: Boolean(options.debug) };
 
@@ -585,11 +916,14 @@ async function ensureQoderReady(provider, options = {}) {
   let refreshed = false;
   if (!executable) {
     reportQoderNotFound(provider);
-    executable = installQoderCLI(provider);
+    executable = installQoderCLI(provider, { skipIfPresent: true });
     refreshed = true;
   }
   if (!executable) return false;
-  let version = qoderBinaryVersion(executable);
+  const versionGate = ensureMinimumQoderVersion(profile, provider, executable);
+  if (!versionGate.ok) return false;
+  executable = versionGate.executable || executable;
+  let version = versionGate.version;
 
   const paths = qoderPaths(profile);
   const selection = selectQoderConfigRoot(profile, executable, inspectOptions);
@@ -626,7 +960,10 @@ async function ensureQoderReady(provider, options = {}) {
     const reinstalled = installQoderCLI(provider);
     if (reinstalled) {
       executable = reinstalled;
-      version = qoderBinaryVersion(executable);
+      const reinstalledGate = ensureMinimumQoderVersion(profile, provider, executable);
+      if (!reinstalledGate.ok) return false;
+      executable = reinstalledGate.executable || executable;
+      version = reinstalledGate.version;
       verdict = inspectQoderHealth(profile, executable, configRoot, inspectOptions);
       if (verdict.state === "ready") {
         return finishQoderReady(profile, provider, executable, version, configRoot, rootSource);
@@ -665,7 +1002,10 @@ async function ensureQoderReady(provider, options = {}) {
       const reinstalled = installQoderCLI(provider);
       if (reinstalled) {
         executable = reinstalled;
-        version = qoderBinaryVersion(executable);
+        const reinstalledGate = ensureMinimumQoderVersion(profile, provider, executable);
+        if (!reinstalledGate.ok) return false;
+        executable = reinstalledGate.executable || executable;
+        version = reinstalledGate.version;
       }
     }
     log(`${profile.displayName} credentials under ${configRoot} are not usable (${verdict.reason}).`);
@@ -692,12 +1032,17 @@ async function ensureQoderReady(provider, options = {}) {
 
 module.exports = {
   QODER_FAMILY_PROFILES,
+  ensureMinimumQoderVersion,
   ensureQoderReady,
   findInInstallDirs,
   findQoderExecutable,
   inspectQoderHealth,
+  installQoderCLIUnlocked,
   isQoderFamilyProvider,
   qoderBinaryVersion,
+  qoderChildEnv,
+  qoderUpdateLockPaths,
+  qoderVersionMeetsMinimum,
   qoderPaths,
   qoderSearchSummary,
   quoteWindowsArg,
@@ -707,5 +1052,7 @@ module.exports = {
   selectQoderConfigRoot,
   spawnQoderSync,
   waitForQoderLogin,
+  windowsQoderShimInvocation,
+  withQoderUpdateLock,
   writeQoderState,
 };

package/bin/windows-job-runner.ps1

@@ -0,0 +1,126 @@
+param(
+  [Parameter(Mandatory = $true)][int]$TimeoutMs,
+  [Parameter(Mandatory = $true)][string]$Executable,
+  [Parameter(Mandatory = $true)][string]$ArgsBase64
+)
+
+$ErrorActionPreference = "Stop"
+$argumentJson = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($ArgsBase64))
+[string[]]$childArguments = @(ConvertFrom-Json $argumentJson)
+
+if (-not ("AutoWonder.WindowsJobRunner" -as [type])) {
+  Add-Type -TypeDefinition @'
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace AutoWonder {
+  public static class WindowsJobRunner {
+    const uint CREATE_SUSPENDED = 0x00000004;
+    const uint STARTF_USESTDHANDLES = 0x00000100;
+    const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 0x00002000;
+    const uint WAIT_OBJECT_0 = 0;
+    const uint WAIT_TIMEOUT = 258;
+    const int JobObjectExtendedLimitInformation = 9;
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+    struct STARTUPINFO {
+      public int cb; public string lpReserved; public string lpDesktop; public string lpTitle;
+      public int dwX; public int dwY; public int dwXSize; public int dwYSize;
+      public int dwXCountChars; public int dwYCountChars; public int dwFillAttribute;
+      public uint dwFlags; public short wShowWindow; public short cbReserved2;
+      public IntPtr lpReserved2; public IntPtr hStdInput; public IntPtr hStdOutput; public IntPtr hStdError;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    struct PROCESS_INFORMATION { public IntPtr hProcess; public IntPtr hThread; public uint dwProcessId; public uint dwThreadId; }
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
+      public long PerProcessUserTimeLimit; public long PerJobUserTimeLimit; public uint LimitFlags;
+      public UIntPtr MinimumWorkingSetSize; public UIntPtr MaximumWorkingSetSize;
+      public uint ActiveProcessLimit; public UIntPtr Affinity; public uint PriorityClass; public uint SchedulingClass;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    struct IO_COUNTERS {
+      public ulong ReadOperationCount; public ulong WriteOperationCount; public ulong OtherOperationCount;
+      public ulong ReadTransferCount; public ulong WriteTransferCount; public ulong OtherTransferCount;
+    }
+    [StructLayout(LayoutKind.Sequential)]
+    struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
+      public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation; public IO_COUNTERS IoInfo;
+      public UIntPtr ProcessMemoryLimit; public UIntPtr JobMemoryLimit; public UIntPtr PeakProcessMemoryUsed; public UIntPtr PeakJobMemoryUsed;
+    }
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    static extern bool CreateProcessW(string app, StringBuilder commandLine, IntPtr processAttributes,
+      IntPtr threadAttributes, bool inheritHandles, uint flags, IntPtr environment, string cwd,
+      ref STARTUPINFO startupInfo, out PROCESS_INFORMATION processInformation);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern IntPtr CreateJobObject(IntPtr attributes, string name);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern bool SetInformationJobObject(IntPtr job, int infoClass, IntPtr info, uint length);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern uint ResumeThread(IntPtr thread);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern bool GetExitCodeProcess(IntPtr process, out uint exitCode);
+    [DllImport("kernel32.dll", SetLastError = true)] static extern bool TerminateProcess(IntPtr process, uint exitCode);
+    [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int handle);
+    [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+
+    static string Quote(string value) {
+      if (value.Length > 0 && value.IndexOfAny(new[] {' ', '\t', '\n', '\v', '"'}) < 0) return value;
+      var result = new StringBuilder("\""); int slashes = 0;
+      foreach (char ch in value) {
+        if (ch == '\\') { slashes++; continue; }
+        if (ch == '"') { result.Append('\\', slashes * 2 + 1).Append('"'); slashes = 0; continue; }
+        result.Append('\\', slashes).Append(ch); slashes = 0;
+      }
+      result.Append('\\', slashes * 2).Append('"'); return result.ToString();
+    }
+
+    public static int Run(string executable, string[] args, int timeoutMs) {
+      IntPtr job = IntPtr.Zero; PROCESS_INFORMATION process = new PROCESS_INFORMATION();
+      try {
+        job = CreateJobObject(IntPtr.Zero, null);
+        if (job == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateJobObject");
+        var limits = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION();
+        limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        int size = Marshal.SizeOf(limits); IntPtr limitsPtr = Marshal.AllocHGlobal(size);
+        try {
+          Marshal.StructureToPtr(limits, limitsPtr, false);
+          if (!SetInformationJobObject(job, JobObjectExtendedLimitInformation, limitsPtr, (uint)size))
+            throw new Win32Exception(Marshal.GetLastWin32Error(), "SetInformationJobObject");
+        } finally { Marshal.FreeHGlobal(limitsPtr); }
+
+        var command = new StringBuilder(Quote(executable));
+        foreach (string arg in args ?? new string[0]) command.Append(' ').Append(Quote(arg ?? ""));
+        var startup = new STARTUPINFO(); startup.cb = Marshal.SizeOf(startup);
+        startup.dwFlags = STARTF_USESTDHANDLES;
+        startup.hStdInput = GetStdHandle(-10); startup.hStdOutput = GetStdHandle(-11); startup.hStdError = GetStdHandle(-12);
+        if (!CreateProcessW(executable, command, IntPtr.Zero, IntPtr.Zero, true, CREATE_SUSPENDED,
+          IntPtr.Zero, null, ref startup, out process))
+          throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcess");
+        if (!AssignProcessToJobObject(job, process.hProcess)) {
+          TerminateProcess(process.hProcess, 125); throw new Win32Exception(Marshal.GetLastWin32Error(), "AssignProcessToJobObject");
+        }
+        if (ResumeThread(process.hThread) == UInt32.MaxValue) {
+          TerminateProcess(process.hProcess, 125); throw new Win32Exception(Marshal.GetLastWin32Error(), "ResumeThread");
+        }
+        uint wait = WaitForSingleObject(process.hProcess, (uint)Math.Max(1, timeoutMs));
+        if (wait == WAIT_TIMEOUT) { CloseHandle(job); job = IntPtr.Zero; WaitForSingleObject(process.hProcess, 10000); return 124; }
+        if (wait != WAIT_OBJECT_0) throw new Win32Exception(Marshal.GetLastWin32Error(), "WaitForSingleObject");
+        uint exitCode; if (!GetExitCodeProcess(process.hProcess, out exitCode))
+          throw new Win32Exception(Marshal.GetLastWin32Error(), "GetExitCodeProcess");
+        return unchecked((int)exitCode);
+      } finally {
+        if (process.hThread != IntPtr.Zero) CloseHandle(process.hThread);
+        if (process.hProcess != IntPtr.Zero) CloseHandle(process.hProcess);
+        // Closing the last handle synchronously terminates every surviving descendant.
+        if (job != IntPtr.Zero) CloseHandle(job);
+      }
+    }
+  }
+}
+'@
+}
+
+try { exit [AutoWonder.WindowsJobRunner]::Run($Executable, $childArguments, $TimeoutMs) }
+catch { [Console]::Error.WriteLine($_.Exception.ToString()); exit 125 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autowonder",
-  "version": "0.2.154",
+  "version": "0.2.156",
   "description": "AutoWonder local runtime — execute AI agent dispatch packages on your machine",
   "bin": {
     "autowonder": "bin/cli.js"