agents-can-communicate 0.8.4 → 0.9.0

package/node_modules/@agents-can-communicate/adapter-claude-code/src/install.mjs

@@ -156,19 +156,44 @@ async function removeChannelConfig(versionsRoot) {
     { force: true })));
 }
 
+// The bundle's commands are `sh "${CLAUDE_PLUGIN_ROOT}/hooks/acc-hook.sh" <event>`.
+const SHELL_HOOK = /^sh "\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/acc-hook\.sh" (\w+)$/;
+
+/**
+ * Claude Code on Windows runs a hook's shell form through Git Bash, or through
+ * PowerShell where Git is absent, and neither can be relied on to have `sh`.
+ * The exec form - `command` plus `args`, Claude Code 2.1.139 and later - starts
+ * the pinned node directly on the Node shim, with no shell to quote for.
+ */
+async function execFormHooks(file, node) {
+  const document = JSON.parse(await readFile(file, "utf8"));
+  for (const groups of Object.values(document.hooks)) {
+    for (const group of groups) {
+      group.hooks = group.hooks.map(hook => {
+        const [, event] = SHELL_HOOK.exec(hook.command ?? "") ?? [];
+        if (event === undefined) return hook;
+        return { type: "command", command: node,
+          args: ["${CLAUDE_PLUGIN_ROOT}/hooks/acc-hook.mjs", event] };
+      });
+    }
+  }
+  await writeFile(file, `${JSON.stringify(document, null, 2)}\n`);
+}
+
 /** A plugin tree with the shim written and the skill's command baked in. */
-async function layOutPlugin(target, { runner, node, cli }) {
+async function layOutPlugin(target, { runner, node, cli, hostPlatform }) {
   await rm(target, { recursive: true, force: true });
   await cp(bundle, target, { recursive: true });
   // The skill ships with a placeholder where the command belongs: `acc` is not
   // on PATH everywhere, and an agent that cannot run it improvises. The shim
   // carries the pinning so each example can name one path. No data home is
   // pinned here: an operator's own ACC_DATA_HOME still wins for this client.
-  const cliShim = await writeCliShim({ dir: target, cli, node });
-  await bakeSkillCommand({ root: target, cliShim });
+  const cliShim = await writeCliShim({ dir: target, cli, node, platform: hostPlatform });
+  await bakeSkillCommand({ root: target, cliShim, platform: hostPlatform });
   // The bundle's hooks.json names this script, and nothing else writes it.
   await writeHookShim({ dir: path.join(target, "hooks"), adapterId: "claude_code",
-    runner, node });
+    runner, node, platform: hostPlatform });
+  if (hostPlatform === "win32") await execFormHooks(path.join(target, "hooks", "hooks.json"), node);
   // The copy the client reads says which ACC wrote it. The shipped manifest
   // carries no version, so there is nothing in the repository to fall out of
   // step - which is how every client came to report 0.1.6 while running 0.1.9.
@@ -177,7 +202,7 @@ async function layOutPlugin(target, { runner, node, cli }) {
 }
 
 export async function installClaudePlugin({ configDir, runner, cli, keepPreviousVersion = null,
-  node = process.execPath, now = new Date() }) {
+  node = process.execPath, now = new Date(), hostPlatform = process.platform }) {
   // Everything this will merge into, read before a byte is written. A settings
   // file that will not parse used to be discovered after the plugin tree was
   // already on disk, and the install then failed with nineteen files left
@@ -194,12 +219,12 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
   const source = sourceDir(configDir);
   const cached = cachePath(configDir, version);
 
-  await layOutPlugin(source, { runner, node, cli });
+  await layOutPlugin(source, { runner, node, cli, hostPlatform });
   await writeJson(marketplaceFile(configDir), marketplaceManifest());
   // The copy the client runs from. Written here rather than asking the user to
   // run `claude plugin install`, exactly as the Codex adapter does, because the
   // command's only effect is this copy plus the two registry entries below.
-  await layOutPlugin(cached, { runner, node, cli });
+  await layOutPlugin(cached, { runner, node, cli, hostPlatform });
   // The copy just written, plus the one an upgrade moved off. A client caches a
   // plugin under its version, so every upgrade would otherwise leave the previous
   // release's tree beside this one - invisible while the version never moved,

package/node_modules/@agents-can-communicate/adapter-codex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-codex/src/app-server-client.mjs

@@ -1,9 +1,12 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
 import os from "node:os";
 import path from "node:path";
 import { realpath, stat } from "node:fs/promises";
 
-import { compareVersionOrder, versionOrder } from "@agents-can-communicate/adapter-sdk";
+import { compareVersionOrder, isWindowsPlatform, versionOrder } from "@agents-can-communicate/adapter-sdk";
 
+import { DAEMON_LAYOUTS } from "./daemon-layouts.mjs";
 import { openWebSocketPeer } from "./ws-json-rpc.mjs";
 
 // The Codex App Server queue protocol, captured on codex-cli 0.152.1. Every
@@ -42,8 +45,70 @@ export function isMethodMissing(error) {
     || (error?.code === INVALID_REQUEST && /unknown variant/.test(String(error?.message ?? "")));
 }
 
-export function openCodexAppServer({ socketPath, timeoutMs = 5_000 }) {
-  return openWebSocketPeer({ socketPath, timeoutMs, retainNotifications: false });
+const fileExists = file => stat(file).then(found => found.isFile(), () => false);
+
+/**
+ * Windows: the command that relays stdio to the control socket, run from the
+ * package the daemon runs from, found the way maintenance finds it: the
+ * standalone install when the home has one, else the copy `app-server daemon
+ * start` installs (measured on 0.159.3). An .exe, so it starts without cmd.exe
+ * whatever the socket path holds. Null when the home holds neither.
+ */
+export async function proxyCommand(socketPath, { exists = fileExists } = {}) {
+  const codexHome = path.win32.dirname(path.win32.dirname(socketPath));
+  for (const layout of DAEMON_LAYOUTS) {
+    for (const name of layout.executables.filter(item => item.endsWith(".exe"))) {
+      const file = path.win32.join(codexHome, ...layout.packageDir.split("/"), ...name.split("/"));
+      if (await exists(file)) return { file, args: ["app-server", "proxy", "--sock", socketPath] };
+    }
+  }
+  return null;
+}
+
+// `spawnProxy` is the seam the tests start a stand-in with.
+async function startProxy(socketPath, { resolveProxy, spawnProxy }) {
+  if (spawnProxy !== undefined) return spawnProxy(socketPath);
+  const command = await resolveProxy(socketPath);
+  if (command === null) {
+    throw Object.assign(new Error(`no codex.exe under ${path.win32.dirname(path.win32.dirname(socketPath))}`
+      + " to relay to its daemon"), { code: "ENOENT" });
+  }
+  return spawn(command.file, command.args, { stdio: ["pipe", "pipe", "ignore"], windowsHide: true });
+}
+
+// A child's stdio, once it is started, as the duplex the WebSocket peer speaks
+// over. The peer writes only after "connect".
+function proxyStream(started) {
+  const stream = new EventEmitter();
+  stream.destroyed = false;
+  let child = null;
+  stream.write = data => (stream.destroyed || child === null ? false : child.stdin.write(data));
+  stream.destroy = () => {
+    if (stream.destroyed) return;
+    stream.destroyed = true;
+    child?.stdin.destroy();
+    child?.kill();
+  };
+  Promise.resolve(started).then(running => {
+    child = running;
+    if (stream.destroyed) {
+      child.kill();
+      return;
+    }
+    child.once("spawn", () => stream.emit("connect"));
+    child.stdout.on("data", data => stream.emit("data", data));
+    child.stdin.on("error", error => stream.emit("error", error));
+    child.once("error", error => stream.emit("error", error));
+    child.once("exit", () => stream.emit("close"));
+  }, error => stream.emit("error", error));
+  return stream;
+}
+
+export function openCodexAppServer({ socketPath, timeoutMs = 5_000, platform = process.platform,
+  spawnProxy, resolveProxy = proxyCommand }) {
+  if (!isWindowsPlatform(platform)) return openWebSocketPeer({ socketPath, timeoutMs, retainNotifications: false });
+  return openWebSocketPeer({ timeoutMs, retainNotifications: false,
+    connect: () => proxyStream(startProxy(socketPath, { resolveProxy, spawnProxy })) });
 }
 
 export async function initializeCodex(peer) {

package/node_modules/@agents-can-communicate/adapter-codex/src/daemon-layouts.mjs

@@ -0,0 +1,13 @@
+// The two packages a Codex daemon runs from, measured. The standalone install
+// keeps its PID in app-server.pid (0.154.0-0.159.0); a home with no standalone
+// package gets the daemon's own package from `app-server daemon start` on
+// 0.157.1 and newer, with its PID in daemon.pid (0.159.0, 2026-09-29). A home
+// that has the standalone package keeps using it, so it is looked for first.
+export const DAEMON_LAYOUTS = Object.freeze([
+  { name: "standalone", packageDir: "packages/standalone",
+    executables: ["current/bin/codex", "current/codex", "current/bin/codex.exe"],
+    pidFile: "app-server-daemon/app-server.pid" },
+  { name: "self-installed", packageDir: "packages/app-server-daemon",
+    executables: ["current/bin/codex", "current/bin/codex.exe"],
+    pidFile: "app-server-daemon/daemon.pid" },
+]);

package/node_modules/@agents-can-communicate/adapter-codex/src/embedded-host.mjs

@@ -1,6 +1,5 @@
-import path from "node:path";
+import { readProcessArgs } from "@agents-can-communicate/adapter-sdk";
 
-import { runMaintenanceCommand } from "./maintenance-host.mjs";
 
 // Which process runs a hook tells a daemon-hosted thread from an embedded chat.
 // Measured on 0.158.0: a daemon thread's hook runs under
@@ -20,20 +19,23 @@ const VALUE_OPTIONS = new Set(["-c", "--config", "-m", "--model", "-p", "--profi
   "--disable", "--local-provider"]);
 
 export async function hostArgv(pid) {
-  const result = await runMaintenanceCommand("/bin/ps", ["-o", "args=", "-p", String(pid)],
-    { timeout: 500 });
-  if (result.status !== 0) throw new Error("host process unreadable");
-  return result.stdout.trim().split(/\s+/).filter(Boolean);
+  const argv = await readProcessArgs(pid, { ps: "/bin/ps", timeoutMs: 500 });
+  if (argv === null) throw new Error("host process unreadable");
+  return argv;
 }
 
+// Either separator, and Windows' `.exe` in any case: `codex`, `/usr/local/bin/codex`,
+// `C:\Users\dana\AppData\Local\Programs\OpenAI\Codex\bin\codex.exe`.
+const programName = word => (word ?? "").split(/[\\/]/).at(-1).replace(/\.exe$/i, "").toLowerCase();
+
 // The arguments after Codex itself, or null for any process that is not Codex:
 // `codex ...`, or a node script named codex, as `node [options] codex.js ...`.
 function codexArguments(argv) {
   const [program, ...rest] = argv;
-  if (path.basename(program ?? "") === "codex") return rest;
-  if (path.basename(program ?? "") !== "node") return null;
+  if (programName(program) === "codex") return rest;
+  if (programName(program) !== "node") return null;
   const script = rest.findIndex(word => !word.startsWith("-"));
-  return script >= 0 && path.basename(rest[script]).replace(/\.[mc]?js$/, "") === "codex"
+  return script >= 0 && programName(rest[script]).replace(/\.[mc]?js$/, "") === "codex"
     ? rest.slice(script + 1) : null;
 }
 
@@ -55,11 +57,83 @@ export function interactiveHost(argv) {
   return true;
 }
 
-/** True only when the host was read and is an interactive TUI; never throws. */
-export async function runsEmbedded(pid, argvOf = hostArgv) {
+// Options that make Codex run a chat on its own embedded app server even while
+// the daemon runs. Measured on 0.159.1, which says so only behind its status
+// line: "Running without the shared background server: command-line
+// configuration overrides (-c, --enable, --disable, or --search) requires
+// embedded mode." The same sentence names --profile, --oss, --strict-config,
+// --dangerously-bypass-hook-trust and --no-daemon.
+const EMBEDDING_OPTIONS = new Set(["-c", "--config", "--enable", "--disable", "--search", "-p",
+  "--profile", "--oss", "--strict-config", "--dangerously-bypass-hook-trust", "--no-daemon"]);
+const OPENS_CHAT = new Set(["resume", "fork"]);
+
+// `--config=x` and `-cx` carry their value; both name the option they spell.
+const optionName = word => word.startsWith("--") ? word.split("=", 1)[0] : word.slice(0, 2);
+
+/**
+ * The first option on this interactive command line that keeps the chat
+ * embedded, as typed, or null. Scanning stops at the prompt: `ps` drops quotes,
+ * so a later word may be the prompt's own text.
+ */
+export function embeddingOption(argv) {
+  const words = codexArguments(argv);
+  if (words === null) return null;
+  let value = false;
+  let opened = false;
+  for (const word of words) {
+    if (value) { value = false; continue; }
+    // `--` ends the options: what follows is the prompt, however it reads.
+    if (word === "--") return null;
+    if (word.startsWith("-")) {
+      if (EMBEDDING_OPTIONS.has(optionName(word))) return optionName(word);
+      value = VALUE_OPTIONS.has(word);
+      continue;
+    }
+    if (opened || !OPENS_CHAT.has(word)) return null;
+    opened = true;
+  }
+  return null;
+}
+
+/**
+ * Whether this command line is the Codex app's own app server: `codex
+ * app-server` that listens nowhere, run from inside an app bundle. Read on the
+ * Codex app in ChatGPT.app 26.928: every window serves its threads over stdio
+ * this way, never through the shared daemon (openai/codex#41014), so no other
+ * process can reach them.
+ */
+export function desktopAppServer(argv) {
+  const words = codexArguments(argv);
+  if (words === null || !/\.app\/Contents\//.test(argv[0] ?? "")) return false;
+  if (words.some(word => word === "--listen" || word.startsWith("--listen="))) return false;
+  // The app puts its config overrides before the subcommand:
+  // `codex -c features.code_mode_host=true app-server ...` (26.928).
+  return subcommandOf(words) === "app-server";
+}
+
+// The first word that is neither an option nor an option's value.
+function subcommandOf(words) {
+  let value = false;
+  for (const word of words) {
+    if (value) { value = false; continue; }
+    if (word.startsWith("-")) { value = VALUE_OPTIONS.has(word); continue; }
+    return word;
+  }
+  return null;
+}
+
+/**
+ * For a host that was read and is an interactive TUI, `{ launchOption }` - the
+ * option that keeps it embedded, or null when its command line shows none. For
+ * the Codex app's own app server, `{ launchOption: null, desktop: true }`.
+ * Null for any other host or an unreadable one; never throws.
+ */
+export async function embeddedHost(pid, argvOf = hostArgv) {
   try {
-    return interactiveHost(await argvOf(pid));
+    const argv = await argvOf(pid);
+    if (interactiveHost(argv)) return { launchOption: embeddingOption(argv) };
+    return desktopAppServer(argv) ? { launchOption: null, desktop: true } : null;
   } catch {
-    return false;
+    return null;
   }
 }

package/node_modules/@agents-can-communicate/adapter-codex/src/hooks.mjs

@@ -138,15 +138,25 @@ export function allowOutcome() {
 /**
  * Context for the next turn.
  *
- * This client wraps nothing: a UserPromptSubmit hook's stdout arrives at the
- * model as a `developer` role message, verbatim. So the injection is plain
- * text - emitting Claude Code's JSON envelope would put the envelope itself
- * into the conversation, the same mistake it would be on Kimi Code.
+ * This client wraps nothing: a UserPromptSubmit hook's plain stdout arrives at
+ * the model as a `developer` role message, verbatim, so the ordinary injection
+ * is plain text. Codex also parses a JSON answer - 0.147.0, 0.155.1 and 0.159.1
+ * took `hookSpecificOutput.additionalContext` into the same developer message
+ * and kept the envelope out of the conversation, measured 2026-09-29 - which
+ * is how a notice for the user rides beside the context.
  *
  * The developer role is the most direct channel of the four, which is a reason
  * to be careful with what goes into it: anything a peer wrote must stay framed
  * as data, because at this role the model reads text as instruction.
  */
-export function injectOutcome(context) {
-  return { stdout: context, stderr: "", exitCode: 0 };
+export function injectOutcome(context, notice) {
+  if (typeof notice?.userMessage !== "string") return { stdout: context, stderr: "", exitCode: 0 };
+  // A line the user must see rides as the hook's systemMessage, which Codex
+  // shows in the chat and never sends to the model; the context goes to the
+  // model as additionalContext, the same developer message plain text becomes.
+  // Measured with a probe hook on 0.147.0, 0.155.1 and 0.159.1. Only the ask's
+  // one turn prints JSON; every other turn keeps the plain text above.
+  return { stdout: JSON.stringify({ systemMessage: notice.userMessage,
+    hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext: context } }),
+  stderr: "", exitCode: 0 };
 }

package/node_modules/@agents-can-communicate/adapter-codex/src/install.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 
 import { bakeSkillCommand, blankJson, blankText, removeIfEmpty, removeInstalledTree,
   keepVersions, ownVersion, stampPluginVersion,
-  tomlString, writeCliShim, writeForeignJson, writeHookShim }
+  tomlString, windowsHookCommand, writeCliShim, writeForeignJson, writeHookShim }
   from "@agents-can-communicate/adapter-sdk";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { inspectConfig, readConfig, sandboxOwnership, writeTomlBlock } from "./config-block.mjs";
@@ -92,11 +92,18 @@ async function readJson(file, fallback) {
 // client copies an installed plugin into a cache of its own, so the command has
 // to be absolute: a path relative to the bundle would not survive the copy.
 const shellLiteral = value => `'${String(value).replaceAll("'", "'\\''")}'`;
-const withShim = (wiring, shim) => ({ ...wiring, hooks: Object.fromEntries(
+// On Windows Codex runs `commandWindows` in place of `command`, through
+// PowerShell: the pinned node on the Node shim.
+const withShim = (wiring, shim, windows = null) => ({ ...wiring, hooks: Object.fromEntries(
   Object.entries(wiring.hooks).map(([event, entries]) => [event, entries.map(entry => ({
     ...entry,
-    hooks: entry.hooks.map(hook => ({ ...hook,
-      command: `sh ${shellLiteral(shim)} ${hook.command.split(" ").pop()}` })),
+    hooks: entry.hooks.map(hook => {
+      const event = hook.command.split(" ").pop();
+      if (windows === null) return { ...hook, command: `sh ${shellLiteral(shim)} ${event}` };
+      return { ...hook,
+        command: windowsHookCommand("portable", { node: windows.node, shim, args: [event] }),
+        commandWindows: windowsHookCommand("powershell", { node: windows.node, shim, args: [event] }) };
+    }),
   }))])) });
 
 const writeJson = async (file, value) => {
@@ -163,7 +170,8 @@ const sandboxReview = (config, file, stateRoot) =>
 
 export async function installCodexPlugin({ home, agentsHome = home,
   codexHome = path.join(home, ".codex"), dataHome, stateRoot, runner, node, cli, keepPreviousVersion = null,
-  requestedLivePolicy, livePolicy, clientVersion, platform, receiverSockets }) {
+  requestedLivePolicy, livePolicy, clientVersion, platform, receiverSockets,
+  hostPlatform = process.platform }) {
   // Read before writing, so a manifest that will not parse is found before a
   // plugin tree is laid down that nothing will then be able to remove.
   const existing = await readJson(marketplacePath(agentsHome), { name: MARKETPLACE,
@@ -194,12 +202,13 @@ export async function installCodexPlugin({ home, agentsHome = home,
   // The skill ships with a placeholder where the command belongs: `acc` is
   // not on PATH everywhere, and an agent that cannot run it improvises. The
   // shim carries the pinning so each example can name one path.
-  const cliShim = await writeCliShim({ dir: target, cli, node, dataHome });
-  await bakeSkillCommand({ root: target, cliShim });
+  const cliShim = await writeCliShim({ dir: target, cli, node, dataHome, platform: hostPlatform });
+  await bakeSkillCommand({ root: target, cliShim, platform: hostPlatform });
   const shim = await writeHookShim({ dir: target, adapterId: "codex",
-    dataHome, runner, node });
+    dataHome, runner, node, platform: hostPlatform });
   await writeJson(path.join(target, "hooks.json"),
-    withShim(await readJson(path.join(bundle, "hooks.json"), { hooks: {} }), shim));
+    withShim(await readJson(path.join(bundle, "hooks.json"), { hooks: {} }), shim,
+      hostPlatform === "win32" ? { node: node ?? process.execPath } : null));
 
   const file = marketplacePath(agentsHome);
   // Ownership is the entry's own name. Recording it as an extra key beside the

package/node_modules/@agents-can-communicate/adapter-codex/src/maintenance-host.mjs

@@ -1,28 +1,29 @@
 import { execFile } from "node:child_process";
 import { constants } from "node:fs";
-import { access, lstat, open, realpath } from "node:fs/promises";
+import { access, lstat, realpath } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+
+import { closedTo, isWindowsPlatform, openRegularNoFollow, readWindowsProcess, resolveExecutable,
+  runExecutable } from "@agents-can-communicate/adapter-sdk";
+
 import { compareVersions, versionOrder } from "./app-server-client.mjs";
+import { DAEMON_LAYOUTS } from "./daemon-layouts.mjs";
+import { socketIsReady } from "./native-endpoint.mjs";
 
 export const MINIMUM_MAINTENANCE_CLI = "0.154.0";
 export const absolute = value => typeof value === "string" && path.isAbsolute(value)
   && !/[\0\r\n]/.test(value);
 export const failMaintenance = reasonCode => { throw Object.assign(new Error(reasonCode), { reasonCode }); };
 const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
+// `ps -o lstart` on POSIX; a FILETIME string on Windows, where Codex records one
+// and WMI reports one to the microsecond (measured on 0.159.3).
+const FILETIME = /^\d{15,19}$/;
 export const startTimeValid = value => typeof value === "string"
-  && /^[A-Z][a-z]{2} [A-Z][a-z]{2} [ \d]\d \d\d:\d\d:\d\d \d{4}$/.test(value);
-// The two packages a Codex daemon runs from, measured. The standalone install
-// keeps its PID in app-server.pid (0.154.0-0.159.0); a home with no standalone
-// package gets the daemon's own package from `app-server daemon start` on
-// 0.157.1 and newer, with its PID in daemon.pid (0.159.0, 2026-09-29). A home
-// that has the standalone package keeps using it, so it is looked for first.
-const DAEMON_LAYOUTS = Object.freeze([
-  { name: "standalone", packageDir: "packages/standalone", executables: ["current/bin/codex", "current/codex"],
-    pidFile: "app-server-daemon/app-server.pid" },
-  { name: "self-installed", packageDir: "packages/app-server-daemon", executables: ["current/bin/codex"],
-    pidFile: "app-server-daemon/daemon.pid" },
-]);
+  && (/^[A-Z][a-z]{2} [A-Z][a-z]{2} [ \d]\d \d\d:\d\d:\d\d \d{4}$/.test(value) || FILETIME.test(value));
+// WMI keeps a creation time in microseconds and a FILETIME counts tenths of one.
+const sameStart = (observed, recorded) => (FILETIME.test(observed ?? "") && FILETIME.test(recorded ?? "")
+  ? BigInt(observed) / 10n === BigInt(recorded) / 10n : observed === recorded);
 export const managedExecutablePaths = codexHome => DAEMON_LAYOUTS.flatMap(layout =>
   layout.executables.map(name => path.join(codexHome, layout.packageDir, name)));
 
@@ -41,6 +42,13 @@ export async function resolveLsof({ access: check = access } = {}) {
 }
 
 export function runMaintenanceCommand(command, args, options) {
+  // Windows finds codex as an npm .cmd, which starts only through cmd.exe.
+  if (process.platform === "win32") {
+    return runExecutable(command, args, { timeout: 20_000, ...options, maxBuffer: 131_072 })
+      .then(({ stdout, stderr }) => ({ status: 0, stdout, stderr }),
+        error => ({ status: typeof error?.code === "number" ? error.code : null,
+          stdout: error?.stdout ?? "", stderr: error?.stderr ?? "" }));
+  }
   return new Promise(resolve => execFile(command, args,
     { timeout: 20_000, ...options, maxBuffer: 131_072, windowsHide: true },
     (error, stdout, stderr) => resolve({ status: error ?
@@ -96,6 +104,11 @@ export async function metadataExists(file) {
 }
 
 async function resolveCli(pathEnv) {
+  if (process.platform === "win32") {
+    const found = await resolveExecutable("codex", { pathEnv });
+    if (found !== null) return found;
+    failMaintenance("maintenance_cli_unavailable");
+  }
   for (const directory of String(pathEnv ?? "").split(path.delimiter)) {
     if (!absolute(directory)) continue;
     const candidate = path.join(directory, "codex");
@@ -130,12 +143,12 @@ export async function probeMaintenanceInstall(paths, run) {
   return { cliPath, cliVersion: version, managedVersion };
 }
 
-export async function readMaintenancePid(file) {
+export async function readMaintenancePid(file, { platform = process.platform } = {}) {
   let handle;
   try {
-    handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    handle = await openRegularNoFollow(file, undefined, { platform });
     const info = await handle.stat();
-    if (!info.isFile() || !own(info) || info.size > 4_096 || (info.mode & 0o022) !== 0) {
+    if (!info.isFile() || !own(info) || info.size > 4_096 || !closedTo(info, 0o022, { platform })) {
       failMaintenance("daemon_identity_unavailable");
     }
     const value = JSON.parse(await handle.readFile("utf8"));
@@ -146,7 +159,23 @@ export async function readMaintenancePid(file) {
   } finally { await handle?.close(); }
 }
 
-export async function observeMaintenanceProcess(pid, paths, run) {
+const processAlive = pid => {
+  try { process.kill(pid, 0); return true; } catch (error) { return error.code === "EPERM"; }
+};
+// Windows reads one process through WMI. An empty answer cannot tell a gone
+// process from an unreadable one, so whether the pid lives is asked first.
+const WINDOWS_SYSTEM = Object.freeze({ alive: processAlive,
+  readProcess: pid => readWindowsProcess(pid, { timeoutMs: 5_000 }) });
+
+export async function observeMaintenanceProcess(pid, paths, run, { system = WINDOWS_SYSTEM } = {}) {
+  if (isWindowsPlatform(paths.platform)) {
+    if (!system.alive(pid)) return { state: "dead" };
+    const found = await system.readProcess(pid).catch(() => null);
+    if (found?.pid !== pid || !startTimeValid(found.start) || typeof found.cmd !== "string") {
+      return { state: "unknown" };
+    }
+    return { state: "alive", processStartTime: found.start, command: found.cmd };
+  }
   const response = await run("/bin/ps", ["-p", String(pid), "-o", "lstart=,command="], paths.options);
   if (response.status === 1 && response.stdout === "" && response.stderr === "") return { state: "dead" };
   if (response.status !== 0) return { state: "unknown" };
@@ -170,16 +199,28 @@ export function socketListedIn(stdout, socketPaths) {
 // `--managed-daemon` appended. The executable must live in the package tree of
 // the installed layout and be the managed binary itself, however it is named.
 const DAEMON_COMMAND = /^(\/.+?) app-server --listen unix:\/\/(?: --managed-daemon)?$/;
-
-export async function verifyMaintenanceProcess(snapshot, paths, run, { lsof = resolveLsof } = {}) {
-  const process = await observeMaintenanceProcess(snapshot.pid, paths, run);
-  const executable = DAEMON_COMMAND.exec(process.command ?? "")?.[1] ?? null;
+// Windows quotes the path and gives it the \\?\ prefix (measured on 0.159.3).
+const WINDOWS_DAEMON_COMMAND = /^"(?:\\\\\?\\)?([^"]+)" app-server --listen unix:\/\/(?: --managed-daemon)?$/;
+
+export async function verifyMaintenanceProcess(snapshot, paths, run, { lsof = resolveLsof,
+  system = WINDOWS_SYSTEM } = {}) {
+  const windows = isWindowsPlatform(paths.platform);
+  const process = await observeMaintenanceProcess(snapshot.pid, paths, run, { system });
+  const executable = (windows ? WINDOWS_DAEMON_COMMAND : DAEMON_COMMAND).exec(process.command ?? "")?.[1]
+    ?? null;
   const packages = (paths.packageDir ?? path.join(paths.codexHome, "packages", "standalone")) + path.sep;
-  if (process.state !== "alive" || process.processStartTime !== snapshot.processStartTime
-    || executable === null || !executable.startsWith(packages)
-    || await realpath(executable).catch(() => null) !== await realpath(paths.managedPath)) {
+  const inside = executable !== null && (windows
+    ? executable.toLowerCase().startsWith(packages.toLowerCase()) : executable.startsWith(packages));
+  if (process.state !== "alive" || !sameStart(process.processStartTime, snapshot.processStartTime)
+    || !inside || await realpath(executable).catch(() => null) !== await realpath(paths.managedPath)) {
     failMaintenance("daemon_identity_unavailable");
   }
+  // Windows has no lsof, and Node's lstat refuses the AF_UNIX socket file; Codex
+  // keeps the socket's directory to its user, and that directory lists it.
+  if (windows) {
+    if (!await socketIsReady(paths.socketPath, { platform: "win32" })) failMaintenance("daemon_socket_unproven");
+    return;
+  }
   // 0.157.1 lists the socket by the path it listens on, not by the symlink it
   // reports; either names the same socket.
   const listening = [paths.socketPath, await realpath(paths.socketPath).catch(() => null)]
@@ -192,8 +233,8 @@ export async function verifyMaintenanceProcess(snapshot, paths, run, { lsof = re
   }
 }
 
-export async function approvedProcessIsDead(expected, paths, run) {
-  const observed = await observeMaintenanceProcess(expected.pid, paths, run);
+export async function approvedProcessIsDead(expected, paths, run, { system = WINDOWS_SYSTEM } = {}) {
+  const observed = await observeMaintenanceProcess(expected.pid, paths, run, { system });
   return observed.state === "dead" || (observed.state === "alive"
-    && observed.processStartTime !== expected.processStartTime);
+    && !sameStart(observed.processStartTime, expected.processStartTime));
 }