negotium 0.18.2 → 0.19.0

package/dist/hosted-agent.js

@@ -1,351 +1,61 @@
 // @bun
 import {
-  __require,
   canonicalMcpBridgeEnv,
   revokeCanonicalMcpBridgeTurn
-} from "./chunk-r0xs3t81.js";
+} from "./chunk-f7p0h1gs.js";
+import {
+  AGENT_HEALTH_SERVER,
+  BASHRS_SPILL_ROOT,
+  BASH_RS_BIN,
+  BASH_RS_VERSION,
+  BG_BASH_BASE_PORT,
+  BG_BASH_MAX_PORT,
+  CANONICAL_MCP_PROXY_SERVER,
+  CLAUDE_EFFORT_VALUES,
+  CLAUDE_EXECUTABLE,
+  DECISION_SERVER,
+  DM_WORKSPACE_DIR,
+  FALLBACK_AGENT,
+  FILE_TAG_REGEX,
+  MODEL_FABLE,
+  MODEL_OPUS,
+  MODEL_SONNET,
+  NEGOTIUM_PORT,
+  PROJECT_ROOT,
+  RUNTIME_MCP_SECRET,
+  RUN_DIR,
+  SESSION_COMM_SERVER,
+  SESSION_WORKSPACE_DIR,
+  SYSTEM_HEALTH_SERVER,
+  TASK_SERVER,
+  TOKEN_STATS_SERVER,
+  TOPIC_WORKSPACE_DIR,
+  TSCONFIG_PATH,
+  TSX_LOADER,
+  VAULT_MASTER_KEY,
+  VAULT_SERVER,
+  WIKI_SERVER,
+  WORKSPACE_DIR,
+  codexAuthFilePath,
+  envText,
+  logger,
+  resolveFallbackAgent,
+  resolveTopicWorkspaceDir
+} from "./chunk-y8rtedjb.js";
+import {
+  __require
+} from "./chunk-2mx7fq49.js";
 
 // ../../packages/core/src/agents/claude-provider.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // ../../packages/core/src/agents/rollout/shared.ts
-import { resolve as resolve3 } from "path";
-
-// ../../packages/core/src/platform/config.ts
-import { execFileSync } from "child_process";
-import { randomBytes } from "crypto";
-import {
-  accessSync,
-  chmodSync,
-  constants,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync
-} from "fs";
-import { createRequire } from "module";
-import { homedir } from "os";
-import { dirname, join, resolve } from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-
-// ../../packages/core/src/types.ts
-var SUPPORTED_AGENTS = ["maestro", "claude", "codex"];
-function isAgentKind(value) {
-  return typeof value === "string" && SUPPORTED_AGENTS.includes(value);
-}
-var CLAUDE_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max"];
-var EFFORT_VALUES = [
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-
-// ../../packages/core/src/platform/config-helpers.ts
-function readEnvText(env, key) {
-  const value = env[key]?.trim();
-  return value || undefined;
-}
-function resolveFallbackAgent(env = process.env) {
-  const value = readEnvText(env, "FALLBACK_AGENT") ?? readEnvText(env, "DEFAULT_AGENT");
-  return isAgentKind(value) ? value : "claude";
-}
-function parseRuntimePort(value, fallback) {
-  if (!value)
-    return fallback;
-  const port = Number.parseInt(value, 10);
-  return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
-}
-function safeRuntimePathSegment(value, fallback, maxLength = 160) {
-  const cleaned = value.trim().replace(/[^A-Za-z0-9._-]/g, "_").replace(/^_+|_+$/g, "").slice(0, maxLength);
-  return cleaned || fallback;
-}
-
-// ../../packages/core/src/platform/logger.ts
-import pino from "pino";
-function createStdioLogger(options = {}) {
-  const development = options.development ?? true;
-  return pino({
-    level: options.level ?? process.env.LOG_LEVEL ?? "info",
-    transport: development ? {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        translateTime: "SYS:yyyy-mm-dd HH:MM:ss",
-        destination: 2
-      }
-    } : undefined
-  }, pino.destination(2));
-}
-var logger = createStdioLogger();
-
-// ../../packages/core/src/platform/config.ts
-function envText(envKey) {
-  return readEnvText(process.env, envKey);
-}
-var HOME = homedir();
-function resolveStateDir() {
-  const configured = envText("NEGOTIUM_STATE_DIR");
-  if (false) {}
-  return configured ? resolve(configured) : resolve(HOME, ".negotium");
-}
-function resolveProjectRoot() {
-  const moduleDir = dirname(fileURLToPath(import.meta.url));
-  const packagedRuntime = resolve(moduleDir, "runtime");
-  if (existsSync(resolve(packagedRuntime, "src")))
-    return packagedRuntime;
-  return resolve(moduleDir, "../..");
-}
-var PROJECT_ROOT = resolveProjectRoot();
-function dependencyBinNames(name) {
-  if (process.platform !== "win32")
-    return [name];
-  return [name, `${name}.exe`, `${name}.cmd`, `${name}.bat`, `${name}.bunx`];
-}
-function resolveDependencyBin(name) {
-  let dir = PROJECT_ROOT;
-  while (true) {
-    const binDir = resolve(dir, "node_modules", ".bin");
-    for (const candidate of dependencyBinNames(name)) {
-      const path = resolve(binDir, candidate);
-      if (existsSync(path))
-        return path;
-    }
-    const parent = dirname(dir);
-    if (parent === dir)
-      return resolve(binDir, name);
-    dir = parent;
-  }
-}
-var STATE_DIR = resolveStateDir();
-function resolveLocalStateDir(envKey, stateName) {
-  const envValue = envText(envKey);
-  if (envValue)
-    return resolve(envValue);
-  return resolve(STATE_DIR, stateName);
-}
-function parsePortEnv(envValue, fallback) {
-  return parseRuntimePort(envValue, fallback);
-}
-var WORKSPACE_DIR = resolveLocalStateDir("NEGOTIUM_WORKSPACE_DIR", "workspace");
-var TOPIC_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "topics");
-var SHARED_WIKI_DIR = resolve(WORKSPACE_DIR, "wiki");
-var CRON_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "cron");
-var BROWSER_DIR = resolveLocalStateDir("NEGOTIUM_BROWSER_DIR", "browser");
-var BROWSER_PROFILES_DIR = resolve(BROWSER_DIR, "profiles");
-var BINARIES_DIR = resolve(STATE_DIR, "binaries");
-var SECRETS_DIR = resolve(STATE_DIR, "secrets");
-var DM_WORKSPACE_DIR = resolve(STATE_DIR, "data", "dm");
-var SESSION_WORKSPACE_DIR = resolve(STATE_DIR, "data", "sessions");
-var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
-var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
-var BINARY_EXTENSION = process.platform === "win32" ? ".exe" : "";
-var BROWSER_RS_VERSION = "v0.6.0";
-var BROWSER_RS_MIN_SECURE_VERSION = "0.2.1";
-function versionAtLeast(actualVersion, minimumVersion) {
-  const actual = actualVersion.split(".").map(Number);
-  const minimum = minimumVersion.split(".").map(Number);
-  if (actual.some(Number.isNaN) || minimum.some(Number.isNaN))
-    return false;
-  for (let index = 0;index < minimum.length; index += 1) {
-    if ((actual[index] ?? 0) > (minimum[index] ?? 0))
-      return true;
-    if ((actual[index] ?? 0) < (minimum[index] ?? 0))
-      return false;
-  }
-  return true;
-}
-var BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000;
-function browserRsMeetsMinimumVersion(candidate) {
-  try {
-    const output = execFileSync(candidate, ["--version"], {
-      encoding: "utf8",
-      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: true
-    }).trim();
-    const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
-    if (!match)
-      return false;
-    return versionAtLeast(match.slice(1).join("."), BROWSER_RS_MIN_SECURE_VERSION);
-  } catch {
-    return false;
-  }
-}
-function resolveBrowserRsBin(envValue) {
-  const override = envValue?.trim();
-  if (!override && !versionAtLeast(BROWSER_RS_VERSION.replace(/^v/, ""), BROWSER_RS_MIN_SECURE_VERSION)) {
-    return;
-  }
-  const candidate = override ? resolve(override) : resolve(BINARIES_DIR, "browser-rs", BROWSER_RS_VERSION, `browser-rs${BINARY_EXTENSION}`);
-  try {
-    accessSync(candidate, constants.X_OK);
-    return browserRsMeetsMinimumVersion(candidate) ? candidate : undefined;
-  } catch {
-    return;
-  }
-}
-var SNIPPETS_API_URL = (envText("NEGOTIUM_SNIPPETS_API_URL") ?? envText("SNIPPETS_API_URL") ?? "").replace(/\/+$/, "");
-var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
-var BASH_RS_VERSION = "v0.1.10";
-function resolveBashRsBin(envValue) {
-  const override = envValue?.trim();
-  const candidate = override ? resolve(override) : resolve(BINARIES_DIR, "bash-rs", BASH_RS_VERSION, `bash-rs${BINARY_EXTENSION}`);
-  try {
-    accessSync(candidate, constants.X_OK);
-    return candidate;
-  } catch {
-    return;
-  }
-}
-var BASH_RS_BIN = resolveBashRsBin(envText("NEGOTIUM_BASH_RS_BIN"));
-function resolveBrowserMcpBin(envValue) {
-  const override = envValue?.trim();
-  if (override)
-    return resolve(override);
-  return BROWSER_RS_BIN ?? resolve(BINARIES_DIR, "browser-rs", BROWSER_RS_VERSION, `browser-rs${BINARY_EXTENSION}`);
-}
-var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
-var TSX_BIN = resolveDependencyBin("tsx");
-var TSX_LOADER_PATH = createRequire(import.meta.url).resolve("tsx");
-var TSX_LOADER = process.platform === "win32" ? pathToFileURL(TSX_LOADER_PATH).href : TSX_LOADER_PATH;
-var TSCONFIG_PATH = resolve(PROJECT_ROOT, "tsconfig.json");
-var SESSION_COMM_SERVER = resolve(PROJECT_ROOT, "src/mcp/session-comm/server.ts");
-var TASK_SERVER = resolve(PROJECT_ROOT, "src/mcp/task-server.ts");
-var DECISION_SERVER = resolve(PROJECT_ROOT, "src/mcp/decision-server.ts");
-var CANONICAL_MCP_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/canonical-proxy-server.ts");
-var WIKI_SERVER = resolve(PROJECT_ROOT, "src/mcp/wiki-server.ts");
-var TOKEN_STATS_SERVER = resolve(PROJECT_ROOT, "src/mcp/token-stats-server.ts");
-var COMPACTION_LOG_SERVER = resolve(PROJECT_ROOT, "src/mcp/compaction-log-server.ts");
-var SYSTEM_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/system-health-server.ts");
-var AGENT_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/agent-health-server.ts");
-var VAULT_SERVER = resolve(PROJECT_ROOT, "src/mcp/vault-server.ts");
-var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
-var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
-function safeWorkspaceSegment(value, fallback) {
-  return safeRuntimePathSegment(value, fallback);
-}
-function resolveTopicWorkspaceDir(topicId) {
-  return join(TOPIC_WORKSPACE_DIR, safeWorkspaceSegment(topicId, "topic"));
-}
-function loadOrCreateLocalSecret(envKey, filename, options = {}) {
-  const envValue = envText(envKey);
-  const secretFile = resolve(SECRETS_DIR, filename);
-  mkdirSync(dirname(secretFile), { recursive: true });
-  if (envValue) {
-    if (options.persistEnvValue) {
-      writeFileSync(secretFile, `${envValue}
-`, { mode: 384 });
-      chmodSync(secretFile, 384);
-    }
-    return envValue;
-  }
-  if (existsSync(secretFile)) {
-    const stored = readFileSync(secretFile, "utf-8").trim();
-    if (stored) {
-      chmodSync(secretFile, 384);
-      return stored;
-    }
-  }
-  const secret = randomBytes(32).toString("base64url");
-  try {
-    writeFileSync(secretFile, `${secret}
-`, { mode: 384, flag: "wx" });
-    return secret;
-  } catch (error) {
-    if (error.code !== "EEXIST")
-      throw error;
-    const stored = readFileSync(secretFile, "utf-8").trim();
-    if (!stored)
-      throw new Error(`Secret file exists but is empty: ${secretFile}`);
-    chmodSync(secretFile, 384);
-    return stored;
-  }
-}
-var RUNTIME_MCP_SECRET = loadOrCreateLocalSecret("RUNTIME_MCP_SECRET", "runtime-mcp-secret");
-var NODE_CONTROL_TOKEN = loadOrCreateLocalSecret("NEGOTIUM_CONTROL_TOKEN", "node-control-token");
-var NODE_ID = loadOrCreateLocalSecret("NEGOTIUM_NODE_ID", "node-id");
-var VAULT_MASTER_KEY = loadOrCreateLocalSecret("NEGOTIUM_VAULT_MASTER_KEY", "vault-master-key", { persistEnvValue: true });
-delete process.env.NEGOTIUM_VAULT_MASTER_KEY;
-var NEGOTIUM_PORT = parseInt(process.env.NEGOTIUM_PORT || "7777", 10);
-var hostname = process.env.HOSTNAME || "127.0.0.1";
-var DATA_DIR = resolveLocalStateDir("NEGOTIUM_DATA_DIR", "data");
-var LOG_DIR = resolveLocalStateDir("NEGOTIUM_LOG_DIR", "logs");
-var UPLOADS_DIR = resolve(DATA_DIR, "uploads");
-var VAULT_DIR = resolve(DATA_DIR, "vault");
-var SESSIONS_DB = process.env.SESSIONS_DB_PATH ? resolve(process.env.SESSIONS_DB_PATH) : resolve(DATA_DIR, "sessions.db");
-var DEBUG_FILE = resolve(DATA_DIR, "debug-users.json");
-var USERS_LOG_DIR = resolve(DATA_DIR, "users");
-var RUN_DIR = resolveLocalStateDir("NEGOTIUM_RUN_DIR", "runtime");
-var PROGRESS_DIR = resolve(RUN_DIR, "progress");
-var DM_CMD_DIR = resolve(RUN_DIR, "dm-commands");
-var DM_RESP_DIR = resolve(RUN_DIR, "dm-responses");
-var SESSION_INBOX_DIR = resolve(RUN_DIR, "session-inbox");
-var SESSION_ASKS_DIR = resolve(RUN_DIR, "session-asks");
-var BASHRS_SPILL_ROOT = resolve(RUN_DIR, "bashrs");
-var PLAYWRIGHT_BASE_PORT = parsePortEnv(process.env.PLAYWRIGHT_BASE_PORT, 9100);
-var PLAYWRIGHT_MAX_PORT = parsePortEnv(process.env.PLAYWRIGHT_MAX_PORT, 9499);
-var PLAYWRIGHT_PORTS_DIR = resolve(RUN_DIR, "playwright-ports");
-mkdirSync(STATE_DIR, { recursive: true });
-mkdirSync(DATA_DIR, { recursive: true });
-mkdirSync(UPLOADS_DIR, { recursive: true });
-mkdirSync(VAULT_DIR, { recursive: true, mode: 448 });
-mkdirSync(LOG_DIR, { recursive: true });
-mkdirSync(PROGRESS_DIR, { recursive: true });
-mkdirSync(DM_CMD_DIR, { recursive: true });
-mkdirSync(DM_RESP_DIR, { recursive: true });
-mkdirSync(SESSION_INBOX_DIR, { recursive: true });
-mkdirSync(SESSION_ASKS_DIR, { recursive: true });
-mkdirSync(PLAYWRIGHT_PORTS_DIR, { recursive: true });
-mkdirSync(WORKSPACE_DIR, { recursive: true });
-mkdirSync(TOPIC_WORKSPACE_DIR, { recursive: true });
-mkdirSync(SHARED_WIKI_DIR, { recursive: true });
-mkdirSync(CRON_WORKSPACE_DIR, { recursive: true });
-mkdirSync(DM_WORKSPACE_DIR, { recursive: true });
-mkdirSync(SESSION_WORKSPACE_DIR, { recursive: true });
-mkdirSync(BROWSER_DIR, { recursive: true });
-mkdirSync(BROWSER_PROFILES_DIR, { recursive: true });
-mkdirSync(BINARIES_DIR, { recursive: true });
-mkdirSync(SECRETS_DIR, { recursive: true, mode: 448 });
-var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
-var AGENTS_PROMPTS_DIR = resolve(PROJECT_ROOT, "src/prompts/agents");
-var RESOURCES_DIR = resolve(PROJECT_ROOT, "src/resources");
-var ABSOLUTE_PATH_PREFIX = String.raw`(?:[A-Za-z]:[\\/]|\\\\|\/)`;
-var FILE_EXTENSIONS_REGEX = new RegExp(`(?:${ABSOLUTE_PATH_PREFIX}[^\\s"'<>|*?[\\]]+\\.(?:png|jpg|jpeg|gif|webp|svg|pdf|csv|xlsx|xls|json|txt|md|html|zip|py|js|ts|tsx|jsx|css|xml|yaml|yml|docx|pptx))`, "gi");
-var FILE_TAG_REGEX = new RegExp(`\\[FILE:(${ABSOLUTE_PATH_PREFIX}[^\\]]+)\\]`, "gi");
-var MODEL_SONNET = "claude-sonnet-5";
-var MODEL_OPUS = "claude-opus-5";
-var MODEL_FABLE = "claude-fable-5-1";
-var FALLBACK_AGENT = resolveFallbackAgent(process.env);
-var FALLBACK_MODEL = envText("FALLBACK_MODEL") ?? envText("DEFAULT_MODEL");
-var DEFAULT_TOPIC_EFFORT = (() => {
-  const raw = envText("NEGOTIUM_DEFAULT_EFFORT")?.toLowerCase();
-  return raw && EFFORT_VALUES.includes(raw) ? raw : "medium";
-})();
-var FFMPEG_BIN = envText("FFMPEG_BIN");
-var FFPROBE_BIN = envText("FFPROBE_BIN");
-var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
-var FASTER_WHISPER_WRAPPER = envText("FASTER_WHISPER_WRAPPER") ?? resolve(PROJECT_ROOT, "scripts/faster-whisper-wrapper.py");
-var WHISPER_MODEL = envText("WHISPER_MODEL_FILE") ?? "turbo";
-var TESSERACT_BIN = envText("TESSERACT_BIN") ?? "tesseract";
-var PDFTOTEXT_BIN = envText("PDFTOTEXT_BIN") ?? "pdftotext";
-function resolveWhisperBackend() {
-  return envText("WHISPER_BACKEND") === "mlx-whisper" ? "mlx-whisper" : "faster-whisper";
-}
-var WHISPER_BACKEND = resolveWhisperBackend();
-var MLX_WHISPER_BIN = envText("MLX_WHISPER_BIN");
-var WHISPER_MODEL_MLX = envText("WHISPER_MODEL_MLX") ?? "mlx-community/whisper-large-v3-turbo";
-var _envMaxTellDepth = Number.parseInt(process.env.MAX_TELL_DEPTH ?? "", 10);
-var MAX_TELL_DEPTH = Number.isInteger(_envMaxTellDepth) && _envMaxTellDepth > 0 ? _envMaxTellDepth : 20;
-function codexAuthFilePath() {
-  return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(process.env.CODEX_HOME || join(homedir(), ".codex"), "auth.json");
-}
+import { resolve as resolve2 } from "path";
 
 // ../../packages/core/src/platform/paths.ts
-import { dirname as dirname2, isAbsolute, relative, resolve as resolve2, sep } from "path";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
 function toDisplayPath(filePath) {
   return filePath.split(sep).join("/");
 }
@@ -356,23 +66,23 @@ var trustedWorkspaceRoots = [
   DM_WORKSPACE_DIR,
   SESSION_WORKSPACE_DIR,
   TOPIC_WORKSPACE_DIR
-].map((root) => resolve3(root));
-var FIXTURES_DIR = resolve3(PROJECT_ROOT, "src", "agents", "fixtures");
+].map((root) => resolve2(root));
+var FIXTURES_DIR = resolve2(PROJECT_ROOT, "src", "agents", "fixtures");
 
 // ../../packages/core/src/platform/jsonl.ts
 import {
   appendFileSync,
   closeSync,
   fsyncSync,
-  mkdirSync as mkdirSync2,
+  mkdirSync,
   openSync,
-  readFileSync as readFileSync2,
+  readFileSync,
   renameSync,
   statSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync
 } from "fs";
-import { dirname as dirname3 } from "path";
+import { dirname as dirname2 } from "path";
 
 // ../../packages/core/src/platform/file-utils.ts
 import { unlinkSync } from "fs";
@@ -400,8 +110,8 @@ function parseJsonlText(raw) {
 }
 var LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
 function writeJsonlFile(filePath, entries) {
-  const dir = dirname3(filePath);
-  mkdirSync2(dir, { recursive: true });
+  const dir = dirname2(filePath);
+  mkdirSync(dir, { recursive: true });
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   const payload = `${entries.map((e) => JSON.stringify(e)).join(`
 `)}
@@ -409,7 +119,7 @@ function writeJsonlFile(filePath, entries) {
   let fd = null;
   try {
     fd = openSync(tmpPath, "w");
-    writeFileSync2(fd, payload);
+    writeFileSync(fd, payload);
     fsyncSync(fd);
     closeSync(fd);
     fd = null;
@@ -486,11 +196,11 @@ function deepMapStrings(value, fn) {
 
 // ../../packages/core/src/agents/execution-host.ts
 import { AsyncLocalStorage } from "async_hooks";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname4 } from "path";
 
 // ../../packages/core/src/security/sensitive-path.ts
 import { realpathSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 var SENSITIVE_PATH_PATTERNS = [
   /\/\.env(\.|$)/i,
   /\/\.ssh\//i,
@@ -507,7 +217,7 @@ var SENSITIVE_PATH_PATTERNS = [
   /\/sessions\.db(-wal|-shm|-journal)?$/i
 ];
 function isSensitivePath(filePath) {
-  const normalized = resolve4(filePath);
+  const normalized = resolve3(filePath);
   if (SENSITIVE_PATH_PATTERNS.some((p) => p.test(toDisplayPath(normalized))))
     return true;
   try {
@@ -669,8 +379,8 @@ function peerSessionBridgeIpcEnv() {
 }
 
 // ../../packages/core/src/platform/background-bash/manager.ts
-import { execFileSync as execFileSync2, spawn } from "child_process";
-import { randomBytes as randomBytes2 } from "crypto";
+import { execFileSync, spawn } from "child_process";
+import { randomBytes } from "crypto";
 
 // ../../packages/core/src/platform/delay.ts
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -687,7 +397,7 @@ function makeBgBashKey(_userId, _topic) {
 }
 function defaultPortPids(port) {
   try {
-    return execFileSync2("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim().split(`
+    return execFileSync("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim().split(`
 `).map((pid) => Number.parseInt(pid, 10)).filter((pid) => !Number.isNaN(pid));
   } catch {
     return [];
@@ -698,8 +408,8 @@ function createBackgroundBashManager(options = {}) {
   const usedPorts = new Set;
   const spawning = new Map;
   const knownContexts = new Map;
-  const runtimeCapability = options.capability ?? randomBytes2(32).toString("hex");
-  const runtimeServerId = options.serverId ?? randomBytes2(16).toString("hex");
+  const runtimeCapability = options.capability ?? randomBytes(32).toString("hex");
+  const runtimeServerId = options.serverId ?? randomBytes(16).toString("hex");
   const bashRsBin = options.bashRsBin ?? BASH_RS_BIN;
   const basePort = options.basePort ?? BG_BASH_BASE_PORT;
   const maxPort = options.maxPort ?? BG_BASH_MAX_PORT;
@@ -859,12 +569,12 @@ function createBackgroundBashManager(options = {}) {
     usedPorts.clear();
     knownContexts.clear();
     const deadline = now() + 3000;
-    await Promise.all(entries.map((instance) => new Promise((resolve5) => {
+    await Promise.all(entries.map((instance) => new Promise((resolve4) => {
       if (instance.process.exitCode !== null || instance.process.killed)
-        return resolve5();
-      instance.process.once("exit", resolve5);
-      instance.process.once("error", resolve5);
-      const timer = setTimeout(resolve5, Math.max(0, deadline - now()));
+        return resolve4();
+      instance.process.once("exit", resolve4);
+      instance.process.once("error", resolve4);
+      const timer = setTimeout(resolve4, Math.max(0, deadline - now()));
       timer.unref?.();
     })));
   }
@@ -959,9 +669,9 @@ var RESERVED_TOPIC_NAMES = new Set([
 var GENERAL_TOPIC_ID = "general";
 
 // ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname as dirname4, join as join2, resolve as resolve5 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join, resolve as resolve4 } from "path";
 
 // ../../packages/core/src/storage/sqlite.ts
 var isBun = typeof process.versions.bun === "string";
@@ -1049,16 +759,16 @@ function storageState() {
 }
 function envPath(name, fallback) {
   const value = process.env[name]?.trim();
-  return resolve5(value || fallback);
+  return resolve4(value || fallback);
 }
 function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join2(homedir2(), ".negotium"));
+  return envPath("NEGOTIUM_STATE_DIR", join(homedir(), ".negotium"));
 }
 function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join2(defaultStateDir(), "data"));
+  return envPath("NEGOTIUM_DATA_DIR", join(defaultStateDir(), "data"));
 }
 function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join2(resolveStorageDataDir(), "sessions.db"));
+  return envPath("SESSIONS_DB_PATH", join(resolveStorageDataDir(), "sessions.db"));
 }
 var SQLITE_INIT_RETRY_MS = 25;
 var SQLITE_INIT_TIMEOUT_MS = 5000;
@@ -1096,7 +806,7 @@ function defaultDatabase() {
     return state.fallbackDatabase;
   if (state.fallbackDatabase)
     closeDatabase(state.fallbackDatabase);
-  mkdirSync3(dirname4(path), { recursive: true });
+  mkdirSync2(dirname3(path), { recursive: true });
   state.fallbackDatabase = new Database(path, { create: true });
   state.fallbackDatabasePath = path;
   initializeDatabase(state.fallbackDatabase);
@@ -2153,11 +1863,11 @@ function hideProviderIntrospectionForOtium(servers, topicId) {
 }
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4 } from "fs";
-import { join as join3 } from "path";
+import { chmodSync, mkdirSync as mkdirSync3 } from "fs";
+import { join as join2 } from "path";
 
 // ../../packages/core/src/storage/vault-crypto-core.ts
-import { createCipheriv, createDecipheriv, createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
+import { createCipheriv, createDecipheriv, createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 var ENVELOPE_PREFIX = "otium-vault:v1:";
 var IV_BYTES = 12;
 var KEY_BYTES = 32;
@@ -2171,7 +1881,7 @@ function isEncryptedVaultValue(value) {
   return value.startsWith(ENVELOPE_PREFIX);
 }
 function encryptVaultValueWithKey(userId, key, value, masterKey) {
-  const iv = randomBytes3(IV_BYTES);
+  const iv = randomBytes2(IV_BYTES);
   const cipher = createCipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
   cipher.setAAD(aad(userId, key));
   const ciphertext = Buffer.concat([cipher.update(value, "utf8"), cipher.final()]);
@@ -2245,11 +1955,11 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join3(dataDir, "vault");
-  const path = join3(vaultDir, "vault.db");
-  mkdirSync4(vaultDir, { recursive: true, mode: 448 });
+  const vaultDir = join2(dataDir, "vault");
+  const path = join2(vaultDir, "vault.db");
+  mkdirSync3(vaultDir, { recursive: true, mode: 448 });
   const database = new Database(path, { create: true });
-  chmodSync2(path, 384);
+  chmodSync(path, 384);
   initializeVaultDatabase(database);
   return database;
 }
@@ -2411,7 +2121,7 @@ function hostedCodexAuthFilePath() {
   return activeHost().codexAuthFilePath();
 }
 function hostedCodexHomePath() {
-  return dirname5(hostedCodexAuthFilePath());
+  return dirname4(hostedCodexAuthFilePath());
 }
 
 // ../../packages/core/src/media/file-events.ts
@@ -2531,7 +2241,7 @@ function buildClaudePrompt(opts) {
         source: {
           type: "base64",
           media_type: attachment.mimeType,
-          data: readFileSync3(attachment.path).toString("base64")
+          data: readFileSync2(attachment.path).toString("base64")
         }
       });
     } catch (err) {
@@ -2558,8 +2268,8 @@ var CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500;
 var claudeProcessExitListeners = new WeakMap;
 function watchClaudeProcessExit(signal) {
   let listener;
-  const exited = new Promise((resolve6) => {
-    listener = resolve6;
+  const exited = new Promise((resolve5) => {
+    listener = resolve5;
     const listeners = claudeProcessExitListeners.get(signal) ?? new Set;
     listeners.add(listener);
     claudeProcessExitListeners.set(signal, listeners);
@@ -2693,7 +2403,7 @@ function isAbortError(err) {
 }
 async function* claudeProvider(opts) {
   const claudeExecutable = hostedClaudeCodeExecutablePath();
-  if (claudeExecutable && !existsSync2(claudeExecutable)) {
+  if (claudeExecutable && !existsSync(claudeExecutable)) {
     yield {
       type: "error",
       content: `Claude CLI not found at ${claudeExecutable}. Install Claude Code or configure the executable path.`
@@ -2991,40 +2701,40 @@ async function* claudeProvider(opts) {
 }
 
 // ../../packages/core/src/agents/codex-provider.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync6, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join7, relative as relative2, resolve as resolve8 } from "path";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync6, readFileSync as readFileSync5, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join7, relative as relative2, resolve as resolve7 } from "path";
 import { Codex } from "@openai/codex-sdk";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn3 } from "child_process";
 import { randomUUID } from "crypto";
 import {
-  chmodSync as chmodSync3,
+  chmodSync as chmodSync2,
   copyFileSync,
-  existsSync as existsSync3,
+  existsSync as existsSync2,
   mkdtempSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   renameSync as renameSync2,
   rmSync,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync2
 } from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire } from "module";
 import { tmpdir } from "os";
-import { dirname as dirname6, join as join4 } from "path";
+import { dirname as dirname5, join as join3 } from "path";
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.18.2";
+var NEGOTIUM_VERSION = "0.19.0";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
-var moduleRequire = createRequire2(import.meta.url);
+var moduleRequire = createRequire(import.meta.url);
 var codexSdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
-var codexSdkRequire = createRequire2(codexSdkPackagePath);
+var codexSdkRequire = createRequire(codexSdkPackagePath);
 var bundledCodexPackagePath = codexSdkRequire.resolve("@openai/codex/package.json");
 function readPackageVersion(packageJsonPath) {
-  const parsed = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+  const parsed = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
   if (typeof parsed.version !== "string" || !parsed.version.trim()) {
     throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
   }
@@ -3035,7 +2745,7 @@ var SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/
 var NEGOTIUM_MODEL_CACHE = `negotium-models-cache-${SAFE_BUNDLED_CODEX_VERSION}.json`;
 var NEGOTIUM_MODEL_CATALOG = `negotium-model-catalog-${SAFE_BUNDLED_CODEX_VERSION}.json`;
 function codexCliScriptPath() {
-  return join4(dirname6(bundledCodexPackagePath), "bin", "codex.js");
+  return join3(dirname5(bundledCodexPackagePath), "bin", "codex.js");
 }
 function parseCodexModelCache(contents, sourcePath) {
   let parsed;
@@ -3050,7 +2760,7 @@ function parseCodexModelCache(contents, sourcePath) {
   return parsed;
 }
 function readCodexModelCache(cachePath) {
-  const contents = readFileSync4(cachePath, "utf8");
+  const contents = readFileSync3(cachePath, "utf8");
   return { contents, parsed: parseCodexModelCache(contents, cachePath) };
 }
 function readCompatibleCodexModelCache(cachePath) {
@@ -3062,13 +2772,13 @@ function readCompatibleCodexModelCache(cachePath) {
   return cache;
 }
 function writePrivateFileAtomic(path, contents) {
-  if (existsSync3(path) && readFileSync4(path, "utf8") === contents)
+  if (existsSync2(path) && readFileSync3(path, "utf8") === contents)
     return;
   const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
   try {
-    writeFileSync3(tempPath, contents, { encoding: "utf8", mode: 384 });
+    writeFileSync2(tempPath, contents, { encoding: "utf8", mode: 384 });
     renameSync2(tempPath, path);
-    chmodSync3(path, 384);
+    chmodSync2(path, 384);
   } finally {
     try {
       unlinkSync3(tempPath);
@@ -3076,7 +2786,7 @@ function writePrivateFileAtomic(path, contents) {
   }
 }
 function bundledCodexModelCachePath(authFilePath) {
-  return join4(dirname6(authFilePath), NEGOTIUM_MODEL_CACHE);
+  return join3(dirname5(authFilePath), NEGOTIUM_MODEL_CACHE);
 }
 async function bootstrapCodexModelCache(codexHome, cachePath) {
   const child = spawn3(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
@@ -3084,7 +2794,7 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
     stdio: ["pipe", "pipe", "pipe"],
     windowsHide: true
   });
-  await new Promise((resolve6, reject) => {
+  const refreshed = new Promise((resolve5, reject) => {
     let settled = false;
     let stdoutBuffer = "";
     let stderr = "";
@@ -3100,10 +2810,10 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
       } catch {}
       if (error)
         reject(error);
-      else if (!existsSync3(cachePath))
+      else if (!existsSync2(cachePath))
         reject(new Error("Codex did not create its model cache"));
       else
-        resolve6();
+        resolve5();
     };
     const send = (message) => {
       child.stdin.write(`${JSON.stringify(message)}
@@ -3160,47 +2870,74 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
       }
     });
   });
+  try {
+    await refreshed;
+  } finally {
+    await waitForChildExit(child, CODEX_BOOTSTRAP_EXIT_WAIT_MS);
+  }
+}
+var CODEX_BOOTSTRAP_EXIT_WAIT_MS = 3000;
+function waitForChildExit(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null)
+    return Promise.resolve();
+  return new Promise((resolve5) => {
+    const timer = setTimeout(resolve5, timeoutMs);
+    timer.unref?.();
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve5();
+    });
+  });
+}
+function removeIsolatedCodexHome(dir) {
+  if (process.platform !== "win32") {
+    rmSync(dir, { recursive: true, force: true });
+    return;
+  }
+  try {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  } catch {}
 }
 async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
-  const sourceHome = dirname6(authFilePath);
-  const isolatedHome = mkdtempSync(join4(tmpdir(), "negotium-codex-models-"));
-  const isolatedCachePath = join4(isolatedHome, "models_cache.json");
+  const sourceHome = dirname5(authFilePath);
+  const isolatedHome = mkdtempSync(join3(tmpdir(), "negotium-codex-models-"));
+  const isolatedCachePath = join3(isolatedHome, "models_cache.json");
   try {
-    const isolatedAuthPath = join4(isolatedHome, "auth.json");
+    const isolatedAuthPath = join3(isolatedHome, "auth.json");
     copyFileSync(authFilePath, isolatedAuthPath);
-    chmodSync3(isolatedAuthPath, 384);
-    const sourceConfigPath = join4(sourceHome, "config.toml");
-    if (existsSync3(sourceConfigPath)) {
-      const isolatedConfigPath = join4(isolatedHome, "config.toml");
+    chmodSync2(isolatedAuthPath, 384);
+    const sourceConfigPath = join3(sourceHome, "config.toml");
+    if (existsSync2(sourceConfigPath)) {
+      const isolatedConfigPath = join3(isolatedHome, "config.toml");
       copyFileSync(sourceConfigPath, isolatedConfigPath);
-      chmodSync3(isolatedConfigPath, 384);
+      chmodSync2(isolatedConfigPath, 384);
     }
     await bootstrap(isolatedHome, isolatedCachePath);
     return readCompatibleCodexModelCache(isolatedCachePath).contents;
   } finally {
-    rmSync(isolatedHome, { recursive: true, force: true });
+    removeIsolatedCodexHome(isolatedHome);
   }
 }
 async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
-  const codexHome = dirname6(authFilePath);
+  const codexHome = dirname5(authFilePath);
   const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
   if (configuredCachePath) {
-    if (!existsSync3(configuredCachePath)) {
+    if (!existsSync2(configuredCachePath)) {
       throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
     }
     readCompatibleCodexModelCache(configuredCachePath);
     return configuredCachePath;
   }
   const bundledCachePath = bundledCodexModelCachePath(authFilePath);
-  const sharedCachePath = join4(codexHome, "models_cache.json");
-  if (existsSync3(sharedCachePath)) {
+  const sharedCachePath = join3(codexHome, "models_cache.json");
+  if (existsSync2(sharedCachePath)) {
     try {
       const shared = readCompatibleCodexModelCache(sharedCachePath);
       writePrivateFileAtomic(bundledCachePath, shared.contents);
       return bundledCachePath;
     } catch {}
   }
-  if (existsSync3(bundledCachePath)) {
+  if (existsSync2(bundledCachePath)) {
     try {
       readCompatibleCodexModelCache(bundledCachePath);
       return bundledCachePath;
@@ -3211,8 +2948,8 @@ async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexMod
   return bundledCachePath;
 }
 function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
-  const codexHome = dirname6(authFilePath);
-  const outputPath = join4(codexHome, NEGOTIUM_MODEL_CATALOG);
+  const codexHome = dirname5(authFilePath);
+  const outputPath = join3(codexHome, NEGOTIUM_MODEL_CATALOG);
   const parsed = readCodexModelCache(sourcePath).parsed;
   const models = parsed.models.map((model, index) => {
     if (!model || typeof model !== "object" || Array.isArray(model)) {
@@ -3227,7 +2964,7 @@ function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath)
 }
 
 // ../../packages/core/src/agents/codex-tree-kill.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 
 // ../../packages/core/src/agents/codex-tree-manager.ts
 function createCodexTreeManager(host, options = {}) {
@@ -3282,12 +3019,12 @@ function createCodexTreeManager(host, options = {}) {
     const previous = spawnChain;
     let release;
     let released = false;
-    spawnChain = new Promise((resolve6) => {
+    spawnChain = new Promise((resolve5) => {
       release = () => {
         if (released)
           return;
         released = true;
-        resolve6();
+        resolve5();
       };
     });
     await previous;
@@ -3394,7 +3131,7 @@ function createCodexTreeManager(host, options = {}) {
       return;
     const deadline = Date.now() + Math.max(0, graceMs);
     while (Date.now() < deadline && hasSurvivors(plan.targets)) {
-      await new Promise((resolve6) => setTimeout(resolve6, Math.min(100, Math.max(1, deadline - Date.now()))));
+      await new Promise((resolve5) => setTimeout(resolve5, Math.min(100, Math.max(1, deadline - Date.now()))));
     }
     killStragglers(plan);
   }
@@ -3413,7 +3150,7 @@ function createCodexTreeManager(host, options = {}) {
 // ../../packages/core/src/agents/codex-tree-kill.ts
 function execText(command, args) {
   try {
-    return execFileSync3(command, args, {
+    return execFileSync2(command, args, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       windowsHide: true
@@ -3447,30 +3184,162 @@ var killCodexTrees = manager.killTrees;
 var killOwnedCodexTreesForShutdown = manager.killOwnedTreesForShutdown;
 
 // ../../packages/core/src/agents/codex-vault-hook-bridge.ts
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 import { existsSync as existsSync4 } from "fs";
-import { chmod, mkdtemp, rm, writeFile } from "fs/promises";
+import { chmod, copyFile, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { createServer } from "net";
 import { tmpdir as tmpdir2 } from "os";
-import { dirname as dirname7, join as join5, resolve as resolve6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname6, join as join5, resolve as resolve5 } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/core/src/agents/codex-windows-wrapper.ts
+import { execFile } from "child_process";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir, rename, rm, writeFile } from "fs/promises";
+import { join as join4 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var CODEX_WINDOWS_WRAPPER_SOURCE = String.raw`
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+static class CodexHookWrapper {
+  [StructLayout(LayoutKind.Sequential)]
+  struct IO_COUNTERS { public ulong a, b, c, d, e, f; }
+  [StructLayout(LayoutKind.Sequential)]
+  struct BASIC {
+    public long PerProcessUserTimeLimit, PerJobUserTimeLimit;
+    public uint LimitFlags;
+    public UIntPtr MinimumWorkingSetSize, MaximumWorkingSetSize;
+    public uint ActiveProcessLimit;
+    public UIntPtr Affinity;
+    public uint PriorityClass, SchedulingClass;
+  }
+  [StructLayout(LayoutKind.Sequential)]
+  struct EXTENDED {
+    public BASIC Basic;
+    public IO_COUNTERS Io;
+    public UIntPtr ProcessMemoryLimit, JobMemoryLimit, PeakProcessMemoryUsed, PeakJobMemoryUsed;
+  }
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
+  static extern IntPtr CreateJobObject(IntPtr attrs, string name);
+  [DllImport("kernel32.dll")]
+  static extern bool SetInformationJobObject(IntPtr job, int cls, IntPtr info, uint len);
+  [DllImport("kernel32.dll")]
+  static extern bool AssignProcessToJobObject(IntPtr job, IntPtr process);
+
+  static string Quote(string a) {
+    if (a.Length > 0 && a.IndexOfAny(new[] { ' ', '\t', '\n', '\v', '"' }) < 0) return a;
+    var sb = new StringBuilder("\"");
+    int bs = 0;
+    foreach (char c in a) {
+      if (c == '\\') { bs++; }
+      else if (c == '"') { sb.Append('\\', bs * 2 + 1); sb.Append('"'); bs = 0; }
+      else { sb.Append('\\', bs); bs = 0; sb.Append(c); }
+    }
+    sb.Append('\\', bs * 2);
+    sb.Append('"');
+    return sb.ToString();
+  }
+
+  static IntPtr KillOnCloseJob() {
+    IntPtr job = CreateJobObject(IntPtr.Zero, null);
+    if (job == IntPtr.Zero) return IntPtr.Zero;
+    var info = new EXTENDED();
+    info.Basic.LimitFlags = 0x2000; // JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+    int size = Marshal.SizeOf(typeof(EXTENDED));
+    IntPtr mem = Marshal.AllocHGlobal(size);
+    try {
+      Marshal.StructureToPtr(info, mem, false);
+      if (!SetInformationJobObject(job, 9, mem, (uint)size)) return IntPtr.Zero;
+    } finally { Marshal.FreeHGlobal(mem); }
+    return job;
+  }
+
+  static int Main(string[] args) {
+    string self = Process.GetCurrentProcess().MainModule.FileName;
+    string[] cfg = File.ReadAllLines(Path.ChangeExtension(self, ".cfg"), Encoding.UTF8);
+    if (cfg.Length < 4) { Console.Error.WriteLine("codex hook wrapper: bad config"); return 70; }
+    var sb = new StringBuilder(Quote(cfg[1]));
+    int i = 0;
+    if (args.Length > 0 && args[0] == "exec") {
+      sb.Append(" exec --dangerously-bypass-hook-trust");
+      i = 1;
+    }
+    for (; i < args.Length; i++) sb.Append(' ').Append(Quote(args[i]));
+
+    // No CreateNoWindow: with it the child stops inheriting our stdio handles.
+    var psi = new ProcessStartInfo(cfg[0], sb.ToString());
+    psi.UseShellExecute = false;
+    psi.EnvironmentVariables["NEGOTIUM_CODEX_VAULT_HOOK_SOCKET"] = cfg[2];
+    psi.EnvironmentVariables["NEGOTIUM_CODEX_VAULT_HOOK_TOKEN"] = cfg[3];
+    IntPtr job = KillOnCloseJob();
+    using (Process p = Process.Start(psi)) {
+      if (job != IntPtr.Zero) AssignProcessToJobObject(job, p.Handle);
+      p.WaitForExit();
+      return p.ExitCode;
+    }
+  }
+}
+`;
+function cscPath() {
+  const windir = process.env.WINDIR ?? process.env.SystemRoot ?? "C:\\Windows";
+  for (const framework of ["Framework64", "Framework"]) {
+    const candidate = join4(windir, "Microsoft.NET", framework, "v4.0.30319", "csc.exe");
+    if (existsSync3(candidate))
+      return candidate;
+  }
+  throw new Error("csc.exe (.NET Framework 4) was not found, so the Codex hook wrapper cannot be built");
+}
+async function ensureCodexWindowsWrapperExe(cacheDir) {
+  const digest = createHash3("sha256").update(CODEX_WINDOWS_WRAPPER_SOURCE).digest("hex").slice(0, 12);
+  const exePath = join4(cacheDir, `codex-hook-wrapper-${digest}.exe`);
+  if (existsSync3(exePath))
+    return exePath;
+  await mkdir(cacheDir, { recursive: true });
+  const stamp = randomUUID2();
+  const sourcePath = join4(cacheDir, `wrapper-${stamp}.cs`);
+  const tempExe = join4(cacheDir, `wrapper-${stamp}.exe`);
+  try {
+    await writeFile(sourcePath, CODEX_WINDOWS_WRAPPER_SOURCE, "utf8");
+    await execFileAsync(cscPath(), ["/nologo", "/target:exe", "/optimize+", `/out:${tempExe}`, sourcePath], { windowsHide: true, timeout: 60000 });
+    try {
+      await rename(tempExe, exePath);
+    } catch (error) {
+      if (!existsSync3(exePath))
+        throw error;
+    }
+    return exePath;
+  } catch (error) {
+    const detail = error && typeof error === "object" && "stdout" in error ? String(error.stdout ?? "").trim() : "";
+    throw new Error(`Failed to build the Codex hook wrapper: ${error instanceof Error ? error.message : String(error)}${detail ? `
+${detail}` : ""}`);
+  } finally {
+    await rm(sourcePath, { force: true });
+    await rm(tempExe, { force: true });
+  }
+}
 
 // ../../packages/core/src/platform/ipc.ts
-import { createHash as createHash3 } from "crypto";
-import { chmodSync as chmodSync4 } from "fs";
+import { createHash as createHash4 } from "crypto";
+import { chmodSync as chmodSync3 } from "fs";
 import { basename } from "path";
 var IS_WINDOWS = process.platform === "win32";
 function ipcEndpoint(posixSocketPath) {
   if (!IS_WINDOWS)
     return posixSocketPath;
   const label = basename(posixSocketPath).replace(/\.sock$/, "").replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 48) || "endpoint";
-  const digest = createHash3("sha256").update(posixSocketPath).digest("hex").slice(0, 16);
+  const digest = createHash4("sha256").update(posixSocketPath).digest("hex").slice(0, 16);
   return `\\\\.\\pipe\\negotium-${label}-${digest}`;
 }
 function restrictIpcEndpoint(endpoint) {
   if (IS_WINDOWS)
     return;
-  chmodSync4(endpoint, 384);
+  chmodSync3(endpoint, 384);
 }
 
 // ../../packages/core/src/agents/codex-vault-hook-bridge.ts
@@ -3505,11 +3374,11 @@ function shellQuote(value) {
   return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
 function hookClientPath() {
-  const moduleDir = dirname7(fileURLToPath2(import.meta.url));
-  const adjacent = resolve6(moduleDir, "codex-vault-hook.mjs");
+  const moduleDir = dirname6(fileURLToPath(import.meta.url));
+  const adjacent = resolve5(moduleDir, "codex-vault-hook.mjs");
   if (existsSync4(adjacent))
     return adjacent;
-  const packaged = resolve6(moduleDir, "runtime/src/agents/codex-vault-hook.mjs");
+  const packaged = resolve5(moduleDir, "runtime/src/agents/codex-vault-hook.mjs");
   if (existsSync4(packaged))
     return packaged;
   throw new Error("Codex Vault hook client is missing from this installation");
@@ -3528,15 +3397,16 @@ function privateCodexWrapper(codexScript, socketPath, token) {
   ].join(`
 `);
 }
-var WINDOWS_BRIDGE_UNSUPPORTED = "Codex Vault hooks are not available on Windows: the hook-trust bypass can only be passed " + "through a wrapper executable, and the Codex SDK spawns the override without a shell, so a " + ".cmd wrapper cannot run. Use the Claude or Maestro backend on this host.";
+var IS_WINDOWS2 = process.platform === "win32";
+function windowsQuote(value) {
+  return `"${value.replaceAll('"', "\\\"")}"`;
+}
 async function createCodexVaultHookBridge(userId) {
-  if (process.platform === "win32")
-    throw new Error(WINDOWS_BRIDGE_UNSUPPORTED);
   const root = await mkdtemp(join5(tmpdir2(), "negotium-codex-vault-"));
   await chmod(root, 448);
   const socketPath = ipcEndpoint(join5(root, "hook.sock"));
-  const wrapperPath = join5(root, "codex-with-hooks");
-  const token = randomBytes4(32).toString("hex");
+  const wrapperPath = join5(root, IS_WINDOWS2 ? "codex-with-hooks.exe" : "codex-with-hooks");
+  const token = randomBytes3(32).toString("hex");
   const connections = new Set;
   const server = createServer((socket) => {
     connections.add(socket);
@@ -3584,10 +3454,19 @@ async function createCodexVaultHookBridge(userId) {
       });
     });
     restrictIpcEndpoint(socketPath);
-    await writeFile(wrapperPath, privateCodexWrapper(codexCliScriptPath(), socketPath, token), {
-      mode: 448
-    });
-    const command = [shellQuote(process.execPath), shellQuote(hookClientPath())].join(" ");
+    if (IS_WINDOWS2) {
+      const { BINARIES_DIR } = await import("./chunk-22mtr8np.js");
+      const cached = await ensureCodexWindowsWrapperExe(join5(BINARIES_DIR, "codex-hook-wrapper"));
+      await copyFile(cached, wrapperPath);
+      await writeFile2(join5(root, "codex-with-hooks.cfg"), [process.execPath, codexCliScriptPath(), socketPath, token].join(`
+`), { encoding: "utf8", mode: 384 });
+    } else {
+      await writeFile2(wrapperPath, privateCodexWrapper(codexCliScriptPath(), socketPath, token), {
+        mode: 448
+      });
+    }
+    const quote = IS_WINDOWS2 ? windowsQuote : shellQuote;
+    const command = [quote(process.execPath), quote(hookClientPath())].join(" ");
     return {
       codexPathOverride: wrapperPath,
       environment: { [HOOK_SOCKET_ENV]: socketPath, [HOOK_TOKEN_ENV]: token },
@@ -3610,29 +3489,29 @@ async function createCodexVaultHookBridge(userId) {
         for (const socket of connections)
           socket.destroy();
         await new Promise((resolveClose) => server.close(() => resolveClose()));
-        await rm(root, { recursive: true, force: true });
+        await rm2(root, { recursive: true, force: true });
       }
     };
   } catch (error) {
     server.close();
-    await rm(root, { recursive: true, force: true });
+    await rm2(root, { recursive: true, force: true });
     throw error;
   }
 }
 
 // ../../packages/core/src/agents/rollout/codex.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
-import { basename as basename2, dirname as dirname8, join as join6, resolve as resolve7 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync as realpathSync2, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
+import { basename as basename2, dirname as dirname7, join as join6, resolve as resolve6 } from "path";
 function codexSessionsDir() {
   return join6(hostedCodexHomePath(), "sessions");
 }
 function canonicalFilePath(path) {
-  const absolute = resolve7(path);
+  const absolute = resolve6(path);
   try {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join6(realpathSync2(dirname8(absolute)), basename2(absolute));
+      return join6(realpathSync2(dirname7(absolute)), basename2(absolute));
     } catch {
       return absolute;
     }
@@ -3742,7 +3621,7 @@ function readCodexPatchCallIds(threadId) {
   if (!path)
     return [];
   try {
-    return extractCodexPatchCallIds(readFileSync5(path, "utf8"));
+    return extractCodexPatchCallIds(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch ids: rollout read failed");
     return [];
@@ -3753,7 +3632,7 @@ function readLatestCodexPatchPreview(threadId, expectedPaths, consumedCallIds =
   if (!path)
     return;
   try {
-    return extractLatestCodexPatchPreview(readFileSync5(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
+    return extractLatestCodexPatchPreview(readFileSync4(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch preview: rollout read failed");
     return;
@@ -3811,7 +3690,7 @@ function readLatestCodexContextUsage(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexContextUsage(readFileSync5(path, "utf8"));
+    return extractLatestCodexContextUsage(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex context usage: rollout read failed");
     return;
@@ -3822,7 +3701,7 @@ function readLatestCodexTokenTotals(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexTokenTotals(readFileSync5(path, "utf8"));
+    return extractLatestCodexTokenTotals(readFileSync4(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex token totals: rollout read failed");
     return;
@@ -3833,7 +3712,7 @@ function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
   if (!path)
     return false;
   try {
-    const entries = parseJsonlText(readFileSync5(path, "utf8"));
+    const entries = parseJsonlText(readFileSync4(path, "utf8"));
     let changed = false;
     for (const entry of entries) {
       if (entry.type !== "session_meta" && entry.type !== "turn_context")
@@ -4028,12 +3907,12 @@ function codexMcpServerName(name) {
   return CODEX_MCP_SERVER_NAME_OVERRIDES[name] ?? name;
 }
 function globalCodexMcpServerNames(authFilePath) {
-  const configPath = join7(dirname9(authFilePath), "config.toml");
+  const configPath = join7(dirname8(authFilePath), "config.toml");
   if (!existsSync6(configPath))
     return [];
   try {
     const names = new Set;
-    for (const line of readFileSync6(configPath, "utf8").split(`
+    for (const line of readFileSync5(configPath, "utf8").split(`
 `)) {
       const match = line.match(/^\s*\[\s*mcp_servers\.((?:"(?:\\.|[^"])*")|(?:'[^']*')|[^.\]\s]+)(?:[.\]])/);
       const raw = match?.[1];
@@ -4131,9 +4010,9 @@ var CODEX_DIFF_BASELINE_FILE_LIMIT = 200;
 var CODEX_DIFF_BASELINE_BYTE_LIMIT = 16 * 1024 * 1024;
 function canonicalPath(path) {
   try {
-    return realpathSync3(resolve8(path));
+    return realpathSync3(resolve7(path));
   } catch {
-    return resolve8(path);
+    return resolve7(path);
   }
 }
 function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
@@ -4143,7 +4022,7 @@ function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
     const byteLimit = Math.min(CODEX_DIFF_FILE_LIMIT, Math.max(0, maxBytes));
     if (statSync3(path).size > byteLimit)
       return;
-    const content = readFileSync6(path);
+    const content = readFileSync5(path);
     if (content.byteLength > byteLimit || content.includes(0))
       return;
     return content.toString("utf8");
@@ -4177,7 +4056,7 @@ class CodexFilePreviewTracker {
       const code = record.slice(0, 2);
       const path = record.slice(3);
       const remainingBytes = CODEX_DIFF_BASELINE_BYTE_LIMIT - loadedBytes;
-      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve8(this.#root, path), remainingBytes) : undefined;
+      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve7(this.#root, path), remainingBytes) : undefined;
       this.#baseline.set(path, content);
       if (typeof content === "string") {
         loadedFiles += 1;
@@ -4190,7 +4069,7 @@ class CodexFilePreviewTracker {
   preview(path, succeeded) {
     if (!this.#root || !this.#baselineAvailable || !succeeded)
       return {};
-    const absolute = canonicalPath(isAbsolute2(path) ? path : resolve8(this.#cwd, path));
+    const absolute = canonicalPath(isAbsolute2(path) ? path : resolve7(this.#cwd, path));
     const relativePath = relative2(this.#root, absolute);
     if (!relativePath || relativePath.startsWith("..") || isAbsolute2(relativePath))
       return {};
@@ -4214,7 +4093,7 @@ class CodexFilePreviewTracker {
   }
   #git(args, cwd = this.#root ?? undefined) {
     try {
-      return execFileSync4("git", ["-C", cwd ?? ".", ...args], {
+      return execFileSync3("git", ["-C", cwd ?? ".", ...args], {
         encoding: "utf8",
         maxBuffer: CODEX_DIFF_FILE_LIMIT * 4,
         stdio: ["ignore", "pipe", "ignore"],
@@ -4226,7 +4105,7 @@ class CodexFilePreviewTracker {
   }
 }
 async function fileChangeEvents(item, previews, cwd, threadId, consumedPatchCallIds) {
-  const expectedPaths = item.changes.map((change) => isAbsolute2(change.path) ? change.path : resolve8(cwd, change.path));
+  const expectedPaths = item.changes.map((change) => isAbsolute2(change.path) ? change.path : resolve7(cwd, change.path));
   let nativePreview;
   if (threadId && item.status === "completed") {
     await new Promise((resolveDelay) => setTimeout(resolveDelay, 20));
@@ -4395,8 +4274,8 @@ async function* codexProvider(opts) {
     mcpServerCount: Object.keys(codexMcpServers).length
   }, "codexProvider: starting turn");
   const hostedCodexHome = hostedCodexHomePath();
-  const inheritedCodexHome = process.env.CODEX_HOME || join7(homedir3(), ".codex");
-  const codexEnvironment = scopedBrowserCapability || resolve8(hostedCodexHome) !== resolve8(inheritedCodexHome) ? {
+  const inheritedCodexHome = process.env.CODEX_HOME || join7(homedir2(), ".codex");
+  const codexEnvironment = scopedBrowserCapability || resolve7(hostedCodexHome) !== resolve7(inheritedCodexHome) ? {
     ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
     CODEX_HOME: hostedCodexHome,
     ...scopedBrowserCapability ? { [CODEX_BROWSER_CAPABILITY_ENV]: scopedBrowserCapability } : {}
@@ -4695,7 +4574,7 @@ async function* codexProvider(opts) {
 process.env.MAESTRO_SDK_SILENT_BOOTSTRAP ??= "1";
 
 // ../../packages/core/src/agents/maestro-provider.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve8 } from "path";
 import { maestroProvider as sdkMaestroProvider, setMcpResolver } from "maestro-agent-sdk";
 var MAESTRO_DEFAULT_MAX_TOKENS = 32768;
 var PROVIDER_ASK_USER_TOOL = "AskUserQuestion";
@@ -4773,7 +4652,7 @@ function buildProviderOwnedToolBlockHook() {
     }
   };
 }
-var MAESTRO_TOOL_OUTPUT_DIR = resolve9(RUN_DIR, "maestro-tool-outputs");
+var MAESTRO_TOOL_OUTPUT_DIR = resolve8(RUN_DIR, "maestro-tool-outputs");
 function buildMaestroToolResultTruncation(opts) {
   if (opts.toolResultTruncation)
     return opts.toolResultTruncation;
@@ -4806,18 +4685,18 @@ function maestroProvider(opts) {
   return sdkMaestroProvider(sdkOpts);
 }
 // ../../packages/core/src/agents/claude-runtime-inspection.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { createRequire as createRequire3 } from "module";
-import { dirname as dirname10, join as join8 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname as dirname9, join as join8 } from "path";
 var cached;
 function inspectBundledClaudeRuntime() {
   if (cached)
     return cached;
   try {
-    const require2 = createRequire3(import.meta.url);
-    const sdkDir = dirname10(require2.resolve("@anthropic-ai/claude-agent-sdk"));
-    const sdkPackage = JSON.parse(readFileSync7(join8(sdkDir, "package.json"), "utf8"));
-    const manifest = JSON.parse(readFileSync7(join8(sdkDir, "manifest.json"), "utf8"));
+    const require2 = createRequire2(import.meta.url);
+    const sdkDir = dirname9(require2.resolve("@anthropic-ai/claude-agent-sdk"));
+    const sdkPackage = JSON.parse(readFileSync6(join8(sdkDir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync6(join8(sdkDir, "manifest.json"), "utf8"));
     const sdkVersion = typeof sdkPackage.version === "string" ? sdkPackage.version : "";
     const claudeCodeVersion = typeof manifest.version === "string" ? manifest.version : "";
     if (!sdkVersion || !claudeCodeVersion) {
@@ -4890,4 +4769,4 @@ export {
   buildClaudeDisallowedTools
 };
 
-//# debugId=CAE7C2B6A4FAB8F464756E2164756E21
+//# debugId=71D580BB622B76C964756E2164756E21