negotium 0.1.28 → 0.1.30

package/dist/agent-helpers.js

@@ -18,14 +18,23 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = import.meta.require;
 
 // ../../packages/core/src/agents/auth-check.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2, platform } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // ../../packages/core/src/platform/config.ts
+import { execFileSync } from "child_process";
 import { randomBytes } from "crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import {
+  accessSync,
+  chmodSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
@@ -119,7 +128,8 @@ var CONTEXTS_DIR = resolve(WORKSPACE_DIR, "contexts");
 var BROWSER_PROFILES_DIR = resolve(WORKSPACE_DIR, "browser-profiles");
 var DM_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "dm");
 var SESSION_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "sessions");
-var CLAUDE_EXECUTABLE = resolve(HOME, ".local/bin/claude");
+var CLAUDE_EXECUTABLE_ENV = envText("NEGOTIUM_CLAUDE_EXECUTABLE");
+var CLAUDE_EXECUTABLE = CLAUDE_EXECUTABLE_ENV ? resolve(CLAUDE_EXECUTABLE_ENV) : undefined;
 function resolveBrowserMcpBin(envValue) {
   const override = envValue?.trim();
   if (override) {
@@ -132,10 +142,55 @@ function resolveBrowserMcpBin(envValue) {
 }
 var PATCHRIGHT_MCP_BIN = resolve(PROJECT_ROOT, "scripts/mcp-patchright-http.mjs");
 var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_BIN"));
+var BROWSER_RS_VERSION = "v0.1.12";
+var BROWSER_RS_MIN_SECURE_VERSION = "0.1.12";
+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;
+}
+function browserRsMeetsMinimumVersion(candidate) {
+  try {
+    const output = execFileSync(candidate, ["--version"], {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).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(STATE_DIR, "bin", "browser-rs", BROWSER_RS_VERSION, "browser-rs");
+  try {
+    accessSync(candidate, constants.X_OK);
+    return browserRsMeetsMinimumVersion(candidate) ? candidate : undefined;
+  } catch {
+    return;
+  }
+}
+var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
 var TSX_BIN = resolveDependencyBin("tsx");
 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 BROWSER_MCP_SSE_PROXY_SERVER = resolve(PROJECT_ROOT, "src/mcp/browser-sse-proxy-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");
@@ -253,6 +308,231 @@ function codexAuthFilePath() {
   return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(homedir(), ".codex", "auth.json");
 }
 
+// ../../packages/core/src/storage/vault.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+
+// ../../packages/core/src/storage/sqlite.ts
+var isBun = typeof process.versions.bun === "string";
+var Database;
+if (isBun) {
+  ({ Database } = await import("bun:sqlite"));
+} else {
+  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
+  const { DatabaseSync } = await import(nodeSqliteSpecifier);
+
+  class NodeDatabase {
+    #db;
+    constructor(path, options = {}) {
+      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
+    }
+    query(sql) {
+      return this.#db.prepare(sql);
+    }
+    prepare(sql) {
+      return this.#db.prepare(sql);
+    }
+    exec(sql) {
+      this.#db.exec(sql);
+    }
+    run(sql, ...params) {
+      return this.#db.prepare(sql).run(...params);
+    }
+    transaction(fn) {
+      const run = (begin) => (...args) => {
+        this.#db.exec(begin);
+        try {
+          const result = fn(...args);
+          this.#db.exec("COMMIT");
+          return result;
+        } catch (err) {
+          this.#db.exec("ROLLBACK");
+          throw err;
+        }
+      };
+      const tx = run("BEGIN");
+      tx.deferred = run("BEGIN DEFERRED");
+      tx.immediate = run("BEGIN IMMEDIATE");
+      tx.exclusive = run("BEGIN EXCLUSIVE");
+      return tx;
+    }
+    close() {
+      this.#db.close();
+    }
+  }
+  Database = NodeDatabase;
+}
+
+// ../../packages/core/src/storage/vault-crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes2 } from "crypto";
+var ENVELOPE_PREFIX = "otium-vault:v1:";
+var IV_BYTES = 12;
+var KEY_BYTES = 32;
+function encryptionKey(masterKey = VAULT_MASTER_KEY) {
+  return createHash("sha256").update("otium-vault-value-v1\x00", "utf8").update(masterKey, "utf8").digest().subarray(0, KEY_BYTES);
+}
+function aad(userId, key) {
+  return Buffer.from(`${userId}\x00${key.toUpperCase()}`, "utf8");
+}
+function isEncryptedVaultValue(value) {
+  return value.startsWith(ENVELOPE_PREFIX);
+}
+function encryptVaultValue(userId, key, value, masterKey = VAULT_MASTER_KEY) {
+  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()]);
+  const tag = cipher.getAuthTag();
+  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
+}
+function decryptVaultValue(userId, key, storedValue, masterKey = VAULT_MASTER_KEY) {
+  if (!isEncryptedVaultValue(storedValue)) {
+    return { value: storedValue, legacyPlaintext: true };
+  }
+  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
+  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
+  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const iv = Buffer.from(ivPart, "base64url");
+  const ciphertext = Buffer.from(ciphertextPart, "base64url");
+  const tag = Buffer.from(tagPart, "base64url");
+  if (iv.length !== IV_BYTES || tag.length !== 16) {
+    throw new Error("Invalid encrypted vault value");
+  }
+  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
+  decipher.setAAD(aad(userId, key));
+  decipher.setAuthTag(tag);
+  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
+}
+
+// ../../packages/core/src/storage/vault.ts
+var vaultDb;
+var vaultMasterKey = VAULT_MASTER_KEY;
+function initializeVaultDatabase(database) {
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA busy_timeout = 5000");
+  database.exec(`
+  CREATE TABLE IF NOT EXISTS vault (
+    user_id     TEXT    NOT NULL,
+    key         TEXT    NOT NULL,
+    value       TEXT    NOT NULL,
+    description TEXT    NOT NULL DEFAULT '',
+    PRIMARY KEY (user_id, key)
+  )
+  `);
+  {
+    const cols = database.prepare("PRAGMA table_info(vault)").all();
+    const uid = cols.find((c) => c.name === "user_id");
+    if (uid && uid.type.toUpperCase() === "INTEGER") {
+      database.exec("BEGIN");
+      database.exec(`
+      CREATE TABLE vault_migrated (
+        user_id     TEXT    NOT NULL,
+        key         TEXT    NOT NULL,
+        value       TEXT    NOT NULL,
+        description TEXT    NOT NULL DEFAULT '',
+        PRIMARY KEY (user_id, key)
+      )
+    `);
+      database.exec("INSERT INTO vault_migrated SELECT CAST(user_id AS TEXT), key, value, description FROM vault");
+      database.exec("DROP TABLE vault");
+      database.exec("ALTER TABLE vault_migrated RENAME TO vault");
+      database.exec("COMMIT");
+    }
+  }
+}
+function openVaultDatabase(dataDir) {
+  const path = join2(dataDir, "vault.db");
+  mkdirSync2(dataDir, { recursive: true });
+  const database = new Database(path, { create: true });
+  chmodSync2(path, 384);
+  initializeVaultDatabase(database);
+  return database;
+}
+function activeVaultDatabase() {
+  if (!vaultDb)
+    vaultDb = openVaultDatabase(DATA_DIR);
+  return vaultDb;
+}
+var VAULT_VALUE_MAX_BYTES = 64 * 1024;
+function normalizeVaultKey(key) {
+  return key.trim().toUpperCase();
+}
+function decryptRow(userId, key, storedValue) {
+  const database = activeVaultDatabase();
+  const decoded = decryptVaultValue(userId, key, storedValue, vaultMasterKey);
+  if (decoded.legacyPlaintext) {
+    database.prepare("UPDATE vault SET value = ? WHERE user_id = ? AND key = ? AND value = ?").run(encryptVaultValue(userId, key, decoded.value, vaultMasterKey), userId, key, storedValue);
+  }
+  return decoded.value;
+}
+function vaultListWithValues(userId) {
+  const rows = activeVaultDatabase().prepare("SELECT key, description, value FROM vault WHERE user_id = ? ORDER BY key").all(userId);
+  return rows.map((row) => ({
+    key: row.key,
+    description: row.description,
+    value: decryptRow(userId, row.key, row.value)
+  }));
+}
+function vaultGetValue(userId, key) {
+  const normalizedKey = normalizeVaultKey(key);
+  const row = activeVaultDatabase().prepare("SELECT key, value FROM vault WHERE user_id = ? AND key = ?").get(userId, normalizedKey);
+  return row ? decryptRow(userId, row.key, row.value) : undefined;
+}
+function vaultSubstituteDetailed(userId, text) {
+  const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
+  const usedKeys = new Set;
+  const substituted = text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+    const key = normalizeVaultKey(rawKey);
+    const value = entries.get(key);
+    if (value === undefined)
+      return match;
+    usedKeys.add(key);
+    return value;
+  });
+  return { text: substituted, usedKeys: [...usedKeys] };
+}
+function encodedSecretForms(value) {
+  const forms = new Set([
+    value,
+    encodeURIComponent(value),
+    Buffer.from(value, "utf8").toString("base64"),
+    Buffer.from(value, "utf8").toString("base64url"),
+    Buffer.from(value, "utf8").toString("hex")
+  ]);
+  forms.delete("");
+  return [...forms].sort((a, b) => b.length - a.length);
+}
+function redactVaultSecrets(userId, text) {
+  const candidates = vaultListWithValues(userId).flatMap((entry) => encodedSecretForms(entry.value).map((form) => ({ form, key: entry.key }))).sort((a, b) => b.form.length - a.form.length || a.key.localeCompare(b.key));
+  if (candidates.length === 0)
+    return text;
+  const candidatesByFirstCharacter = new Map;
+  for (const candidate of candidates) {
+    const first = candidate.form[0];
+    if (!first)
+      continue;
+    const bucket = candidatesByFirstCharacter.get(first) ?? [];
+    bucket.push(candidate);
+    candidatesByFirstCharacter.set(first, bucket);
+  }
+  let redacted = "";
+  let offset = 0;
+  while (offset < text.length) {
+    const match = candidatesByFirstCharacter.get(text[offset] ?? "")?.find((candidate) => text.startsWith(candidate.form, offset));
+    if (!match) {
+      redacted += text[offset];
+      offset += 1;
+      continue;
+    }
+    redacted += `[REDACTED:${match.key}]`;
+    offset += match.form.length;
+  }
+  return redacted;
+}
+
 // ../../packages/core/src/agents/auth-check.ts
 var defaultAgentAuthHost = {
   codexAuthFilePath,
@@ -262,14 +542,20 @@ var defaultAgentAuthHost = {
   operatingSystem: platform,
   hasMacOsCredential(service) {
     try {
-      execFileSync("security", ["find-generic-password", "-s", service], { stdio: "ignore" });
+      execFileSync2("security", ["find-generic-password", "-s", service], { stdio: "ignore" });
       return true;
     } catch {
       return false;
     }
-  }
+  },
+  getVaultValue: vaultGetValue
 };
-function checkAgentAuth(agent, host = defaultAgentAuthHost) {
+function hasMaestroCredential(host, key, userId) {
+  if (userId && host.getVaultValue(userId, key)?.trim())
+    return true;
+  return Boolean(host.environment[key]?.trim());
+}
+function checkAgentAuth(agent, host = defaultAgentAuthHost, userId) {
   switch (agent) {
     case "codex": {
       const path = host.codexAuthFilePath();
@@ -292,7 +578,7 @@ function checkAgentAuth(agent, host = defaultAgentAuthHost) {
           error: "claude is not logged in (no macOS keychain entry 'Claude Code-credentials'). Run `claude` and complete login first"
         };
       }
-      const path = join2(host.homeDirectory(), ".claude", ".credentials.json");
+      const path = join3(host.homeDirectory(), ".claude", ".credentials.json");
       if (host.exists(path))
         return { ok: true };
       return {
@@ -301,35 +587,35 @@ function checkAgentAuth(agent, host = defaultAgentAuthHost) {
       };
     }
     case "maestro": {
-      if (host.environment.DEEPSEEK_API_KEY || host.environment.MOONSHOT_API_KEY) {
+      if (hasMaestroCredential(host, "DEEPSEEK_API_KEY", userId) || hasMaestroCredential(host, "MOONSHOT_API_KEY", userId)) {
         return { ok: true };
       }
       return {
         ok: false,
-        error: "maestro is not authenticated (neither DEEPSEEK_API_KEY nor MOONSHOT_API_KEY env var is set)"
+        error: "maestro is not authenticated (set DEEPSEEK_API_KEY or MOONSHOT_API_KEY via /vault set, or as an env var)"
       };
     }
   }
 }
-function checkAgentModelAuth(agent, model, host = defaultAgentAuthHost) {
+function checkAgentModelAuth(agent, model, host = defaultAgentAuthHost, userId) {
   if (agent !== "maestro")
-    return checkAgentAuth(agent, host);
+    return checkAgentAuth(agent, host, userId);
   if (model.startsWith("kimi")) {
-    return host.environment.MOONSHOT_API_KEY ? { ok: true } : {
+    return hasMaestroCredential(host, "MOONSHOT_API_KEY", userId) ? { ok: true } : {
       ok: false,
-      error: `maestro is not authenticated for model '${model}' (MOONSHOT_API_KEY env var not set)`
+      error: `maestro is not authenticated for model '${model}' (set MOONSHOT_API_KEY via /vault set, or as an env var)`
     };
   }
   if (model.startsWith("deepseek")) {
-    return host.environment.DEEPSEEK_API_KEY ? { ok: true } : {
+    return hasMaestroCredential(host, "DEEPSEEK_API_KEY", userId) ? { ok: true } : {
       ok: false,
-      error: `maestro is not authenticated for model '${model}' (DEEPSEEK_API_KEY env var not set)`
+      error: `maestro is not authenticated for model '${model}' (set DEEPSEEK_API_KEY via /vault set, or as an env var)`
     };
   }
-  return checkAgentAuth(agent, host);
+  return checkAgentAuth(agent, host, userId);
 }
 // ../../packages/core/src/agents/codex-tree-kill.ts
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 
 // ../../packages/core/src/agents/codex-tree-manager.ts
 function createCodexTreeManager(host, options = {}) {
@@ -515,7 +801,7 @@ function createCodexTreeManager(host, options = {}) {
 // ../../packages/core/src/agents/codex-tree-kill.ts
 function execText(command, args) {
   try {
-    return execFileSync2(command, args, {
+    return execFileSync3(command, args, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -550,23 +836,23 @@ var killOwnedCodexTreesForShutdown = manager.killOwnedTreesForShutdown;
 import { existsSync as existsSync7, unlinkSync as unlinkSync7 } from "fs";
 
 // ../../packages/core/src/agents/claude-registry.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync, renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync, renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // ../../packages/core/src/agents/rollout/claude.ts
 import { randomUUID } from "crypto";
 import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // ../../packages/core/src/agents/rollout/shared.ts
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 var trustedWorkspaceRoots = [WORKSPACE_DIR, DM_WORKSPACE_DIR, TOPIC_WORKSPACE_DIR].map((root) => resolve2(root));
-var FIXTURES_DIR = join3(__dirname2, "..", "fixtures");
+var FIXTURES_DIR = join4(__dirname2, "..", "fixtures");
 function clone(obj) {
   return structuredClone(obj);
 }
@@ -586,7 +872,7 @@ function assertCwdInWorkspace(cwd) {
 function ensureCwdExists(cwd) {
   assertCwdInWorkspace(cwd);
   try {
-    mkdirSync2(cwd, { recursive: true });
+    mkdirSync3(cwd, { recursive: true });
   } catch (err) {
     logger.warn({ err, cwd }, "rollout: ensureCwdExists failed \u2014 caller should pre-create cwd");
   }
@@ -676,7 +962,7 @@ import {
   appendFileSync,
   closeSync,
   fsyncSync,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   openSync,
   readFileSync as readFileSync2,
   renameSync,
@@ -739,7 +1025,7 @@ function isStaleLock(lockPath) {
   }
 }
 function appendJsonlLine(filePath, line) {
-  mkdirSync3(dirname3(filePath), { recursive: true });
+  mkdirSync4(dirname3(filePath), { recursive: true });
   const lockPath = `${filePath}${LOCK_SUFFIX}`;
   const payload = line.endsWith(`
 `) ? line : `${line}
@@ -772,7 +1058,7 @@ function appendJsonlLine(filePath, line) {
 }
 function writeJsonlFile(filePath, entries) {
   const dir = dirname3(filePath);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(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(`
 `)}
@@ -817,7 +1103,7 @@ var _attachmentsCache = null;
 function loadClaudeAttachments() {
   if (_attachmentsCache)
     return _attachmentsCache;
-  const raw = readFileSync3(join4(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
+  const raw = readFileSync3(join5(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 2) {
     throw new Error(`loadClaudeAttachments: expected >=2 entries in claude-attachments.jsonl, got ${lines.length}`);
@@ -921,8 +1207,8 @@ function writeClaudeRollout(opts) {
     });
     lastUuid = assistantUuid;
   }
-  const projectsDir = join4(homedir3(), ".claude", "projects", encodeClaudeCwd(opts.cwd));
-  const path = join4(projectsDir, `${sessionId}.jsonl`);
+  const projectsDir = join5(homedir3(), ".claude", "projects", encodeClaudeCwd(opts.cwd));
+  const path = join5(projectsDir, `${sessionId}.jsonl`);
   writeJsonlFile(path, lines);
   logger.info({ sessionId, path, pairs: pairs.length }, "writeClaudeRollout: synthetic rollout placed");
   return { sessionId, rolloutPath: path };
@@ -967,15 +1253,15 @@ var claudeRegistry = {
     const result = await forkSession(parentSessionId, {
       ...title ? { title } : {}
     });
-    const projectsRoot = join5(homedir4(), ".claude", "projects");
-    const destDir = join5(projectsRoot, encodeClaudeCwd(cwd));
-    const destPath = join5(destDir, `${result.sessionId}.jsonl`);
+    const projectsRoot = join6(homedir4(), ".claude", "projects");
+    const destDir = join6(projectsRoot, encodeClaudeCwd(cwd));
+    const destPath = join6(destDir, `${result.sessionId}.jsonl`);
     if (!existsSync4(destPath)) {
-      const sourcePath = readdirSync(projectsRoot).map((d) => join5(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync4(p));
+      const sourcePath = readdirSync(projectsRoot).map((d) => join6(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync4(p));
       if (!sourcePath) {
         throw new Error(`claude forkSession: fork rollout ${result.sessionId}.jsonl not found under ${projectsRoot}`);
       }
-      mkdirSync4(destDir, { recursive: true });
+      mkdirSync5(destDir, { recursive: true });
       renameSync2(sourcePath, destPath);
     }
     return {
@@ -984,10 +1270,10 @@ var claudeRegistry = {
     };
   },
   async cleanupRollouts({ cwd, sessionIds }) {
-    const projectsDir = join5(homedir4(), ".claude", "projects", encodeClaudeCwd(cwd));
+    const projectsDir = join6(homedir4(), ".claude", "projects", encodeClaudeCwd(cwd));
     const failures = [];
     for (const sid of sessionIds) {
-      const path = join5(projectsDir, `${sid}.jsonl`);
+      const path = join6(projectsDir, `${sid}.jsonl`);
       try {
         unlinkSync3(path);
       } catch (e) {
@@ -1006,21 +1292,21 @@ var claudeRegistry = {
 // ../../packages/core/src/agents/codex-registry.ts
 import { unlinkSync as unlinkSync6 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // ../../packages/core/src/agents/rollout/codex.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
+import { randomBytes as randomBytes3 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync4, realpathSync, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { basename, dirname as dirname4, join as join7, resolve as resolve3 } from "path";
 function codexSessionsDir() {
-  return join6(process.env.CODEX_HOME || join6(homedir5(), ".codex"), "sessions");
+  return join7(process.env.CODEX_HOME || join7(homedir5(), ".codex"), "sessions");
 }
 var _shellCache = null;
 function loadCodexShell() {
   if (_shellCache)
     return _shellCache;
-  const raw = readFileSync4(join6(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const raw = readFileSync4(join7(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 5) {
     throw new Error(`loadCodexShell: expected >=5 entries in codex-shell.jsonl, got ${lines.length}`);
@@ -1037,7 +1323,7 @@ function loadCodexShell() {
 function uuidv7() {
   const ts = Date.now();
   const tsHex = ts.toString(16).padStart(12, "0");
-  const rand = randomBytes2(10);
+  const rand = randomBytes3(10);
   rand[0] = rand[0] & 15 | 112;
   rand[2] = rand[2] & 63 | 128;
   return [
@@ -1078,6 +1364,139 @@ function patchEnvContext(envContext, cwd, currentDate, timezone) {
     }
   }
 }
+function canonicalFilePath(path) {
+  const absolute = resolve3(path);
+  try {
+    return realpathSync(absolute);
+  } catch {
+    try {
+      return join7(realpathSync(dirname4(absolute)), basename(absolute));
+    } catch {
+      return absolute;
+    }
+  }
+}
+function changedPatchLines(value) {
+  const removed = [];
+  const added = [];
+  const diffPreview = [];
+  let oldLine = 0;
+  let newLine = 0;
+  let sawHunk = false;
+  for (const line of value.split(`
+`)) {
+    const hunk = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (hunk) {
+      if (sawHunk)
+        diffPreview.push("\u2026");
+      sawHunk = true;
+      oldLine = Number.parseInt(hunk[1] ?? "0", 10);
+      newLine = Number.parseInt(hunk[2] ?? "0", 10);
+      continue;
+    }
+    if (!sawHunk && (line.startsWith("--- ") || line.startsWith("+++ ")))
+      continue;
+    if (line.startsWith("\\ No newline"))
+      continue;
+    if (line.startsWith("-")) {
+      removed.push(line.slice(1));
+      diffPreview.push(`${oldLine} -${line.slice(1)}`);
+      oldLine += 1;
+      continue;
+    }
+    if (line.startsWith("+")) {
+      added.push(line.slice(1));
+      diffPreview.push(`${newLine} +${line.slice(1)}`);
+      newLine += 1;
+      continue;
+    }
+    if (line.startsWith(" ")) {
+      diffPreview.push(`${newLine}  ${line.slice(1)}`);
+      oldLine += 1;
+      newLine += 1;
+    }
+  }
+  return {
+    ...removed.length > 0 ? { before: removed.join(`
+`) } : {},
+    ...added.length > 0 ? { after: added.join(`
+`) } : {},
+    ...diffPreview.length > 0 ? { diffPreview: diffPreview.join(`
+`) } : {}
+  };
+}
+function extractLatestCodexPatchPreview(jsonl, expectedPaths, consumedCallIds = new Set, expectedCallId) {
+  const expected = expectedPaths.map(canonicalFilePath);
+  const lines = jsonl.trimEnd().split(`
+`);
+  for (let index = lines.length - 1;index >= 0; index -= 1) {
+    try {
+      const entry = JSON.parse(lines[index] ?? "");
+      if (entry.type !== "event_msg" || entry.payload?.type !== "patch_apply_end")
+        continue;
+      const callId = entry.payload.call_id;
+      const rawChanges = entry.payload.changes;
+      if (!callId || consumedCallIds.has(callId) || expectedCallId !== undefined && callId !== expectedCallId || !rawChanges) {
+        continue;
+      }
+      const entries = Object.entries(rawChanges);
+      const matched = expected.map((path) => entries.find(([candidate]) => canonicalFilePath(candidate) === path));
+      const complete = matched.filter((change) => change !== undefined);
+      if (complete.length !== expected.length)
+        continue;
+      return {
+        callId,
+        changes: complete.map(([path, change]) => {
+          if (typeof change.unified_diff === "string") {
+            return { path, ...changedPatchLines(change.unified_diff) };
+          }
+          const content = typeof change.content === "string" ? change.content.replace(/\n$/, "") : undefined;
+          return {
+            path,
+            ...change.type === "delete" && content !== undefined ? { before: content } : {},
+            ...change.type === "add" && content !== undefined ? { after: content } : {}
+          };
+        })
+      };
+    } catch {}
+  }
+  return;
+}
+function extractCodexPatchCallIds(jsonl) {
+  const callIds = [];
+  for (const line of jsonl.trimEnd().split(`
+`)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "event_msg" && entry.payload?.type === "patch_apply_end" && typeof entry.payload.call_id === "string") {
+        callIds.push(entry.payload.call_id);
+      }
+    } catch {}
+  }
+  return callIds;
+}
+function readCodexPatchCallIds(threadId) {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path)
+    return [];
+  try {
+    return extractCodexPatchCallIds(readFileSync4(path, "utf8"));
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex patch ids: rollout read failed");
+    return [];
+  }
+}
+function readLatestCodexPatchPreview(threadId, expectedPaths, consumedCallIds = new Set, expectedCallId) {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path)
+    return;
+  try {
+    return extractLatestCodexPatchPreview(readFileSync4(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex patch preview: rollout read failed");
+    return;
+  }
+}
 function extractLatestCodexContextUsage(jsonl) {
   const lines = jsonl.trimEnd().split(`
 `);
@@ -1102,18 +1521,18 @@ function readLatestCodexContextUsage(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join6(sessionsDir, bucket);
+        const dir = join7(sessionsDir, bucket);
         if (!existsSync5(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join6(dir, rel));
+          candidates.push(join7(dir, rel));
         }
       }
     } else {
       const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-        candidates.push(join6(sessionsDir, rel));
+        candidates.push(join7(sessionsDir, rel));
       }
     }
     const path = candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
@@ -1157,19 +1576,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join6(sessionsDir, bucket);
+        const dir = join7(sessionsDir, bucket);
         if (!existsSync5(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join6(dir, rel));
+          candidates.push(join7(dir, rel));
         }
       }
     }
     if (candidates.length === 0) {
       const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-        candidates.push(join6(sessionsDir, rel));
+        candidates.push(join7(sessionsDir, rel));
       }
     }
     return candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
@@ -1278,8 +1697,8 @@ function writeCodexRollout(opts) {
   const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
   const dd = String(now.getUTCDate()).padStart(2, "0");
   const tsStr = tsIso.replace(/[:.]/g, "-").slice(0, 19);
-  const dir = join6(codexSessionsDir(), String(yyyy), mm, dd);
-  const path = join6(dir, `rollout-${tsStr}-${threadId}.jsonl`);
+  const dir = join7(codexSessionsDir(), String(yyyy), mm, dd);
+  const path = join7(dir, `rollout-${tsStr}-${threadId}.jsonl`);
   if (opts.threadId) {
     sweepPriorRolloutsForThread(opts.threadId);
   }
@@ -1295,13 +1714,13 @@ function sweepPriorRolloutsForThread(threadId) {
     return;
   }
   for (const bucket of buckets) {
-    const dir = join6(sessionsDir, bucket);
+    const dir = join7(sessionsDir, bucket);
     if (!existsSync5(dir))
       continue;
     try {
       const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-        const fullPath = join6(dir, rel);
+        const fullPath = join7(dir, rel);
         try {
           unlinkSync4(fullPath);
         } catch (e) {
@@ -1319,7 +1738,7 @@ function sweepPriorRolloutsFullTree(threadId, sessionsDir) {
   try {
     const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
     for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-      const fullPath = join6(sessionsDir, rel);
+      const fullPath = join7(sessionsDir, rel);
       try {
         unlinkSync4(fullPath);
       } catch (e) {
@@ -1379,13 +1798,13 @@ function formatDateBucket(d) {
 // ../../packages/core/src/storage/conversations.ts
 import {
   existsSync as existsSync6,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readFileSync as readFileSync5,
   renameSync as renameSync3,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "fs";
-import { dirname as dirname5, join as join8 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 
 // ../../packages/core/src/security/sanitize.ts
 function sanitizeTopicName(name, lowercase = false) {
@@ -1400,62 +1819,9 @@ function sanitizeFileName(name) {
 }
 
 // ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync5 } from "fs";
+import { mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir6 } from "os";
-import { dirname as dirname4, join as join7, resolve as resolve3 } from "path";
-
-// ../../packages/core/src/storage/sqlite.ts
-var isBun = typeof process.versions.bun === "string";
-var Database;
-if (isBun) {
-  ({ Database } = await import("bun:sqlite"));
-} else {
-  const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
-  const { DatabaseSync } = await import(nodeSqliteSpecifier);
-
-  class NodeDatabase {
-    #db;
-    constructor(path, options = {}) {
-      this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
-    }
-    query(sql) {
-      return this.#db.prepare(sql);
-    }
-    prepare(sql) {
-      return this.#db.prepare(sql);
-    }
-    exec(sql) {
-      this.#db.exec(sql);
-    }
-    run(sql, ...params) {
-      return this.#db.prepare(sql).run(...params);
-    }
-    transaction(fn) {
-      const run = (begin) => (...args) => {
-        this.#db.exec(begin);
-        try {
-          const result = fn(...args);
-          this.#db.exec("COMMIT");
-          return result;
-        } catch (err) {
-          this.#db.exec("ROLLBACK");
-          throw err;
-        }
-      };
-      const tx = run("BEGIN");
-      tx.deferred = run("BEGIN DEFERRED");
-      tx.immediate = run("BEGIN IMMEDIATE");
-      tx.exclusive = run("BEGIN EXCLUSIVE");
-      return tx;
-    }
-    close() {
-      this.#db.close();
-    }
-  }
-  Database = NodeDatabase;
-}
-
-// ../../packages/core/src/storage/storage-host.ts
+import { dirname as dirname5, join as join8, resolve as resolve4 } from "path";
 var configuredHost = {};
 var fallbackDatabase = null;
 var fallbackDatabasePath = null;
@@ -1464,19 +1830,19 @@ var initializedSchemas = new WeakMap;
 var initializingDatabases = new WeakSet;
 function envPath(name, fallback) {
   const value = process.env[name]?.trim();
-  return resolve3(value || fallback);
+  return resolve4(value || fallback);
 }
 function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join7(homedir6(), ".negotium"));
+  return envPath("NEGOTIUM_STATE_DIR", join8(homedir6(), ".negotium"));
 }
 function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join7(defaultStateDir(), "data"));
+  return envPath("NEGOTIUM_DATA_DIR", join8(defaultStateDir(), "data"));
 }
 function defaultWorkspaceDir() {
-  return envPath("NEGOTIUM_WORKSPACE_DIR", join7(defaultStateDir(), "workspace"));
+  return envPath("NEGOTIUM_WORKSPACE_DIR", join8(defaultStateDir(), "workspace"));
 }
 function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join7(resolveStorageDataDir(), "sessions.db"));
+  return envPath("SESSIONS_DB_PATH", join8(resolveStorageDataDir(), "sessions.db"));
 }
 function initializeDatabase(database) {
   database.exec("PRAGMA journal_mode = WAL");
@@ -1493,7 +1859,7 @@ function defaultDatabase() {
     return fallbackDatabase;
   if (fallbackDatabase)
     fallbackDatabase.close();
-  mkdirSync5(dirname4(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   fallbackDatabase = new Database(path, { create: true });
   fallbackDatabasePath = path;
   initializeDatabase(fallbackDatabase);
@@ -1509,7 +1875,7 @@ function resolveStorageWorkspaceDir() {
   return configuredHost.workspaceDir ?? defaultWorkspaceDir();
 }
 function resolveStorageSharedWikiDir() {
-  return configuredHost.sharedWikiDir ?? join7(resolveStorageWorkspaceDir(), "wiki");
+  return configuredHost.sharedWikiDir ?? join8(resolveStorageWorkspaceDir(), "wiki");
 }
 function registerStorageSchemaInitializer(initialize, priority = 100) {
   schemaInitializers.push({ initialize, priority });
@@ -1563,14 +1929,14 @@ function safeUserIdComponent(userId) {
   return str;
 }
 function conversationDir(userId) {
-  return join8(resolveStorageDataDir(), "conversations", safeUserIdComponent(userId));
+  return join9(resolveStorageDataDir(), "conversations", safeUserIdComponent(userId));
 }
 function topicFilename(topicName) {
   const t = sanitizeTopicName(topicName, true);
   return `${t}.jsonl`;
 }
 function getConversationPath(userId, topicName) {
-  return join8(conversationDir(userId), topicFilename(topicName));
+  return join9(conversationDir(userId), topicFilename(topicName));
 }
 function appendConversationEvent(userId, topicName, agent, event) {
   try {
@@ -1586,7 +1952,7 @@ function appendConversationEventStrict(userId, topicName, agent, event) {
     agent,
     event
   };
-  mkdirSync6(dirname5(path), { recursive: true });
+  mkdirSync7(dirname6(path), { recursive: true });
   appendJsonlLine(path, JSON.stringify(entry));
 }
 function readConversation(userId, topicName) {
@@ -1655,13 +2021,13 @@ var codexRegistry = {
   async cleanupRollouts({ sessionIds }) {
     if (sessionIds.length === 0)
       return;
-    const sessionsDir = join9(process.env.CODEX_HOME || join9(homedir7(), ".codex"), "sessions");
+    const sessionsDir = join10(process.env.CODEX_HOME || join10(homedir7(), ".codex"), "sessions");
     const failures = [];
     for (const tid of sessionIds) {
       try {
         const glob = new Bun.Glob(`**/rollout-*-${tid}.jsonl`);
         for await (const rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
-          const path = join9(sessionsDir, rel);
+          const path = join10(sessionsDir, rel);
           try {
             unlinkSync6(path);
           } catch (e) {
@@ -1747,8 +2113,8 @@ function cleanupAgentFork(handle) {
   defaultForkHelpers.cleanupAgentFork(handle);
 }
 // ../../packages/core/src/agents/archiver.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync11, statSync as statSync5 } from "fs";
 import { join as join15 } from "path";
 
 // ../../packages/core/src/agents/index.ts
@@ -1781,8 +2147,8 @@ function deepMapStrings(value, fn) {
 import { AsyncLocalStorage } from "async_hooks";
 
 // ../../packages/core/src/security/sensitive-path.ts
-import { realpathSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve5 } from "path";
 var SENSITIVE_PATH_PATTERNS = [
   /\/\.env(\.|$)/i,
   /\/\.ssh\//i,
@@ -1799,11 +2165,11 @@ var SENSITIVE_PATH_PATTERNS = [
   /\/sessions\.db(-wal|-shm|-journal)?$/i
 ];
 function isSensitivePath(filePath) {
-  const normalized = resolve4(filePath);
+  const normalized = resolve5(filePath);
   if (SENSITIVE_PATH_PATTERNS.some((p) => p.test(normalized)))
     return true;
   try {
-    const real = realpathSync(normalized);
+    const real = realpathSync2(normalized);
     if (real !== normalized)
       return SENSITIVE_PATH_PATTERNS.some((p) => p.test(real));
   } catch {}
@@ -1932,8 +2298,8 @@ function peerSessionBridgeIpcEnv() {
 }
 
 // ../../packages/core/src/platform/background-bash/manager.ts
-import { execFileSync as execFileSync3, spawn } from "child_process";
-import { randomBytes as randomBytes3 } from "crypto";
+import { execFileSync as execFileSync4, spawn } from "child_process";
+import { randomBytes as randomBytes4 } from "crypto";
 
 // ../../packages/core/src/platform/delay.ts
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -1950,7 +2316,7 @@ function makeBgBashKey(_userId, _topic) {
 }
 function defaultPortPids(port) {
   try {
-    return execFileSync3("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim().split(`
+    return execFileSync4("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim().split(`
 `).map((pid) => Number.parseInt(pid, 10)).filter((pid) => !Number.isNaN(pid));
   } catch {
     return [];
@@ -1961,8 +2327,8 @@ function createBackgroundBashManager(options = {}) {
   const usedPorts = new Set;
   const spawning = new Map;
   const knownContexts = new Map;
-  const runtimeCapability = options.capability ?? randomBytes3(32).toString("hex");
-  const runtimeServerId = options.serverId ?? randomBytes3(16).toString("hex");
+  const runtimeCapability = options.capability ?? randomBytes4(32).toString("hex");
+  const runtimeServerId = options.serverId ?? randomBytes4(16).toString("hex");
   const serverFile = options.serverFile ?? BACKGROUND_BASH_SERVER;
   const basePort = options.basePort ?? BG_BASH_BASE_PORT;
   const maxPort = options.maxPort ?? BG_BASH_MAX_PORT;
@@ -2107,12 +2473,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((resolve6) => {
       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 resolve6();
+      instance.process.once("exit", resolve6);
+      instance.process.once("error", resolve6);
+      const timer = setTimeout(resolve6, Math.max(0, deadline - now()));
       timer.unref?.();
     })));
   }
@@ -2201,23 +2567,23 @@ function browserOwnerForContext(ctx) {
 function playwrightTransport(port, owner, capability, agent) {
   const ownerCapability = browserOwnerCapability(capability, owner);
   if (agent === "codex") {
+    const query2 = new URLSearchParams({ owner });
     return {
-      url: `http://127.0.0.1:${port}/mcp`,
-      http_headers: { "X-Browser-Owner": owner },
+      url: `http://127.0.0.1:${port}/mcp?${query2}`,
       env_http_headers: { "X-Browser-Capability": CODEX_BROWSER_CAPABILITY_ENV }
     };
   }
+  const query = new URLSearchParams({ owner });
   if (agent === "maestro") {
-    const query = new URLSearchParams({ owner, capability: ownerCapability });
-    return {
-      type: "sse",
-      url: `http://127.0.0.1:${port}/sse?${query}`
-    };
+    return buildStdioMcpServer("maestro", BROWSER_MCP_SSE_PROXY_SERVER, [], {
+      NEGOTIUM_BROWSER_SSE_URL: `http://127.0.0.1:${port}/sse?${query}`,
+      NEGOTIUM_BROWSER_OWNER_CAPABILITY: ownerCapability
+    });
   }
   return {
     type: "sse",
-    url: `http://127.0.0.1:${port}/sse`,
-    headers: { "X-Browser-Owner": owner, "X-Browser-Capability": ownerCapability }
+    url: `http://127.0.0.1:${port}/sse?${query}`,
+    headers: { "X-Browser-Capability": ownerCapability }
   };
 }
 function longLivedHttpMcp(agent, port) {
@@ -2495,288 +2861,119 @@ function getForumMcpServers(opts) {
   } = opts;
   const filter = (name) => {
     if (silent && name === "task")
-      return false;
-    if (enabled === null)
-      return true;
-    return enabled.includes(name) || REQUIRED_FORUM_MCP_SERVERS.includes(name);
-  };
-  const base = buildScope("forum", {
-    userId,
-    session,
-    topicId,
-    queryId,
-    wikiTopicId,
-    agent,
-    cwd,
-    model,
-    currentUserPrompt,
-    depth,
-    playwrightPort,
-    playwrightCapability,
-    bgBashPort,
-    autoContinue,
-    visualTools,
-    fileDeliveryTools,
-    silent,
-    peerBridge
-  }, filter);
-  return { ...base, ...extra };
-}
-function getCronMcpServers(opts) {
-  return buildScope("cron", {
-    userId: opts.userId,
-    session: opts.session,
-    topicId: opts.topicId,
-    queryId: opts.queryId,
-    wikiTopicId: opts.wikiTopicId ?? opts.topicId,
-    agent: opts.agent,
-    cwd: opts.cwd,
-    model: opts.model,
-    currentUserPrompt: opts.currentUserPrompt,
-    playwrightPort: opts.playwrightPort,
-    playwrightCapability: opts.playwrightCapability,
-    autoContinue: false,
-    visualTools: opts.visualTools,
-    fileDeliveryTools: opts.fileDeliveryTools
-  });
-}
-function getMcpServersForQuery(opts) {
-  if (opts.sessionType === "cron") {
-    if (!opts.topicId)
-      throw new Error("getMcpServersForQuery: cron sessionType requires topicId");
-    return getCronMcpServers({
-      userId: opts.userId || "default",
-      session: opts.session || "cron",
-      topicId: opts.topicId,
-      queryId: opts.queryId,
-      wikiTopicId: opts.wikiTopicId,
-      agent: opts.agent,
-      cwd: opts.cwd,
-      model: opts.model,
-      currentUserPrompt: opts.prompt,
-      playwrightPort: opts.playwrightPort,
-      playwrightCapability: opts.playwrightCapability,
-      visualTools: opts.visualTools,
-      fileDeliveryTools: opts.fileDeliveryTools
-    });
-  }
-  if (opts.sessionType === "dm" || opts.sessionType === "ephemeral") {
-    return getDmMcpServers({
-      userId: opts.userId || "default",
-      agent: opts.agent,
-      playwrightPort: opts.playwrightPort,
-      playwrightCapability: opts.playwrightCapability
-    });
-  }
-  if (opts.sessionType === "manager") {
-    return getManagerMcpServers({
-      userId: opts.userId || "default",
-      session: opts.session,
-      topicId: opts.topicId,
-      queryId: opts.queryId,
-      wikiTopicId: opts.wikiTopicId,
-      agent: opts.agent,
-      cwd: opts.cwd,
-      model: opts.model,
-      currentUserPrompt: opts.prompt,
-      playwrightPort: opts.playwrightPort,
-      playwrightCapability: opts.playwrightCapability,
-      autoContinue: opts.autoContinue,
-      visualTools: opts.visualTools,
-      fileDeliveryTools: opts.fileDeliveryTools
-    });
-  }
-  return getForumMcpServers({
-    userId: opts.userId || "default",
-    session: opts.session || "default",
-    topicId: opts.topicId,
-    queryId: opts.queryId,
-    wikiTopicId: opts.wikiTopicId,
-    agent: opts.agent,
-    cwd: opts.cwd,
-    model: opts.model,
-    currentUserPrompt: opts.prompt,
-    playwrightPort: opts.playwrightPort,
-    playwrightCapability: opts.playwrightCapability,
-    bgBashPort: opts.bgBashPort,
-    autoContinue: opts.autoContinue,
-    visualTools: opts.visualTools,
-    fileDeliveryTools: opts.fileDeliveryTools,
-    depth: opts.depth,
-    enabled: opts.mcpEnabled,
-    extra: opts.mcpExtra,
-    silent: opts.silent,
-    peerBridge: opts.peerBridge
-  });
-}
-
-// ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync7 } from "fs";
-import { join as join10 } from "path";
-
-// ../../packages/core/src/storage/vault-crypto.ts
-import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes4 } from "crypto";
-var ENVELOPE_PREFIX = "otium-vault:v1:";
-var IV_BYTES = 12;
-var KEY_BYTES = 32;
-function encryptionKey(masterKey = VAULT_MASTER_KEY) {
-  return createHash("sha256").update("otium-vault-value-v1\x00", "utf8").update(masterKey, "utf8").digest().subarray(0, KEY_BYTES);
-}
-function aad(userId, key) {
-  return Buffer.from(`${userId}\x00${key.toUpperCase()}`, "utf8");
-}
-function isEncryptedVaultValue(value) {
-  return value.startsWith(ENVELOPE_PREFIX);
-}
-function encryptVaultValue(userId, key, value, masterKey = VAULT_MASTER_KEY) {
-  const iv = randomBytes4(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()]);
-  const tag = cipher.getAuthTag();
-  return `${ENVELOPE_PREFIX}${iv.toString("base64url")}.${ciphertext.toString("base64url")}.${tag.toString("base64url")}`;
-}
-function decryptVaultValue(userId, key, storedValue, masterKey = VAULT_MASTER_KEY) {
-  if (!isEncryptedVaultValue(storedValue)) {
-    return { value: storedValue, legacyPlaintext: true };
-  }
-  const encoded = storedValue.slice(ENVELOPE_PREFIX.length);
-  const [ivPart, ciphertextPart, tagPart, ...extra] = encoded.split(".");
-  if (!ivPart || ciphertextPart === undefined || !tagPart || extra.length > 0) {
-    throw new Error("Invalid encrypted vault value");
-  }
-  const iv = Buffer.from(ivPart, "base64url");
-  const ciphertext = Buffer.from(ciphertextPart, "base64url");
-  const tag = Buffer.from(tagPart, "base64url");
-  if (iv.length !== IV_BYTES || tag.length !== 16) {
-    throw new Error("Invalid encrypted vault value");
-  }
-  const decipher = createDecipheriv("aes-256-gcm", encryptionKey(masterKey), iv);
-  decipher.setAAD(aad(userId, key));
-  decipher.setAuthTag(tag);
-  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-  return { value: plaintext.toString("utf8"), legacyPlaintext: false };
-}
-
-// ../../packages/core/src/storage/vault.ts
-var vaultDb;
-var vaultMasterKey = VAULT_MASTER_KEY;
-function initializeVaultDatabase(database) {
-  database.exec("PRAGMA journal_mode = WAL");
-  database.exec("PRAGMA busy_timeout = 5000");
-  database.exec(`
-  CREATE TABLE IF NOT EXISTS vault (
-    user_id     TEXT    NOT NULL,
-    key         TEXT    NOT NULL,
-    value       TEXT    NOT NULL,
-    description TEXT    NOT NULL DEFAULT '',
-    PRIMARY KEY (user_id, key)
-  )
-  `);
-  {
-    const cols = database.prepare("PRAGMA table_info(vault)").all();
-    const uid = cols.find((c) => c.name === "user_id");
-    if (uid && uid.type.toUpperCase() === "INTEGER") {
-      database.exec("BEGIN");
-      database.exec(`
-      CREATE TABLE vault_migrated (
-        user_id     TEXT    NOT NULL,
-        key         TEXT    NOT NULL,
-        value       TEXT    NOT NULL,
-        description TEXT    NOT NULL DEFAULT '',
-        PRIMARY KEY (user_id, key)
-      )
-    `);
-      database.exec("INSERT INTO vault_migrated SELECT CAST(user_id AS TEXT), key, value, description FROM vault");
-      database.exec("DROP TABLE vault");
-      database.exec("ALTER TABLE vault_migrated RENAME TO vault");
-      database.exec("COMMIT");
-    }
-  }
-}
-function openVaultDatabase(dataDir) {
-  const path = join10(dataDir, "vault.db");
-  mkdirSync7(dataDir, { recursive: true });
-  const database = new Database(path, { create: true });
-  chmodSync2(path, 384);
-  initializeVaultDatabase(database);
-  return database;
-}
-function activeVaultDatabase() {
-  if (!vaultDb)
-    vaultDb = openVaultDatabase(DATA_DIR);
-  return vaultDb;
-}
-var VAULT_VALUE_MAX_BYTES = 64 * 1024;
-function normalizeVaultKey(key) {
-  return key.trim().toUpperCase();
-}
-function decryptRow(userId, key, storedValue) {
-  const database = activeVaultDatabase();
-  const decoded = decryptVaultValue(userId, key, storedValue, vaultMasterKey);
-  if (decoded.legacyPlaintext) {
-    database.prepare("UPDATE vault SET value = ? WHERE user_id = ? AND key = ? AND value = ?").run(encryptVaultValue(userId, key, decoded.value, vaultMasterKey), userId, key, storedValue);
-  }
-  return decoded.value;
-}
-function vaultListWithValues(userId) {
-  const rows = activeVaultDatabase().prepare("SELECT key, description, value FROM vault WHERE user_id = ? ORDER BY key").all(userId);
-  return rows.map((row) => ({
-    key: row.key,
-    description: row.description,
-    value: decryptRow(userId, row.key, row.value)
-  }));
+      return false;
+    if (enabled === null)
+      return true;
+    return enabled.includes(name) || REQUIRED_FORUM_MCP_SERVERS.includes(name);
+  };
+  const base = buildScope("forum", {
+    userId,
+    session,
+    topicId,
+    queryId,
+    wikiTopicId,
+    agent,
+    cwd,
+    model,
+    currentUserPrompt,
+    depth,
+    playwrightPort,
+    playwrightCapability,
+    bgBashPort,
+    autoContinue,
+    visualTools,
+    fileDeliveryTools,
+    silent,
+    peerBridge
+  }, filter);
+  return { ...base, ...extra };
 }
-function vaultSubstituteDetailed(userId, text) {
-  const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
-  const usedKeys = new Set;
-  const substituted = text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
-    const key = normalizeVaultKey(rawKey);
-    const value = entries.get(key);
-    if (value === undefined)
-      return match;
-    usedKeys.add(key);
-    return value;
+function getCronMcpServers(opts) {
+  return buildScope("cron", {
+    userId: opts.userId,
+    session: opts.session,
+    topicId: opts.topicId,
+    queryId: opts.queryId,
+    wikiTopicId: opts.wikiTopicId ?? opts.topicId,
+    agent: opts.agent,
+    cwd: opts.cwd,
+    model: opts.model,
+    currentUserPrompt: opts.currentUserPrompt,
+    playwrightPort: opts.playwrightPort,
+    playwrightCapability: opts.playwrightCapability,
+    autoContinue: false,
+    visualTools: opts.visualTools,
+    fileDeliveryTools: opts.fileDeliveryTools
   });
-  return { text: substituted, usedKeys: [...usedKeys] };
-}
-function encodedSecretForms(value) {
-  const forms = new Set([
-    value,
-    encodeURIComponent(value),
-    Buffer.from(value, "utf8").toString("base64"),
-    Buffer.from(value, "utf8").toString("base64url"),
-    Buffer.from(value, "utf8").toString("hex")
-  ]);
-  forms.delete("");
-  return [...forms].sort((a, b) => b.length - a.length);
 }
-function redactVaultSecrets(userId, text) {
-  const candidates = vaultListWithValues(userId).flatMap((entry) => encodedSecretForms(entry.value).map((form) => ({ form, key: entry.key }))).sort((a, b) => b.form.length - a.form.length || a.key.localeCompare(b.key));
-  if (candidates.length === 0)
-    return text;
-  const candidatesByFirstCharacter = new Map;
-  for (const candidate of candidates) {
-    const first = candidate.form[0];
-    if (!first)
-      continue;
-    const bucket = candidatesByFirstCharacter.get(first) ?? [];
-    bucket.push(candidate);
-    candidatesByFirstCharacter.set(first, bucket);
+function getMcpServersForQuery(opts) {
+  if (opts.sessionType === "cron") {
+    if (!opts.topicId)
+      throw new Error("getMcpServersForQuery: cron sessionType requires topicId");
+    return getCronMcpServers({
+      userId: opts.userId || "default",
+      session: opts.session || "cron",
+      topicId: opts.topicId,
+      queryId: opts.queryId,
+      wikiTopicId: opts.wikiTopicId,
+      agent: opts.agent,
+      cwd: opts.cwd,
+      model: opts.model,
+      currentUserPrompt: opts.prompt,
+      playwrightPort: opts.playwrightPort,
+      playwrightCapability: opts.playwrightCapability,
+      visualTools: opts.visualTools,
+      fileDeliveryTools: opts.fileDeliveryTools
+    });
   }
-  let redacted = "";
-  let offset = 0;
-  while (offset < text.length) {
-    const match = candidatesByFirstCharacter.get(text[offset] ?? "")?.find((candidate) => text.startsWith(candidate.form, offset));
-    if (!match) {
-      redacted += text[offset];
-      offset += 1;
-      continue;
-    }
-    redacted += `[REDACTED:${match.key}]`;
-    offset += match.form.length;
+  if (opts.sessionType === "dm" || opts.sessionType === "ephemeral") {
+    return getDmMcpServers({
+      userId: opts.userId || "default",
+      agent: opts.agent,
+      playwrightPort: opts.playwrightPort,
+      playwrightCapability: opts.playwrightCapability
+    });
   }
-  return redacted;
+  if (opts.sessionType === "manager") {
+    return getManagerMcpServers({
+      userId: opts.userId || "default",
+      session: opts.session,
+      topicId: opts.topicId,
+      queryId: opts.queryId,
+      wikiTopicId: opts.wikiTopicId,
+      agent: opts.agent,
+      cwd: opts.cwd,
+      model: opts.model,
+      currentUserPrompt: opts.prompt,
+      playwrightPort: opts.playwrightPort,
+      playwrightCapability: opts.playwrightCapability,
+      autoContinue: opts.autoContinue,
+      visualTools: opts.visualTools,
+      fileDeliveryTools: opts.fileDeliveryTools
+    });
+  }
+  return getForumMcpServers({
+    userId: opts.userId || "default",
+    session: opts.session || "default",
+    topicId: opts.topicId,
+    queryId: opts.queryId,
+    wikiTopicId: opts.wikiTopicId,
+    agent: opts.agent,
+    cwd: opts.cwd,
+    model: opts.model,
+    currentUserPrompt: opts.prompt,
+    playwrightPort: opts.playwrightPort,
+    playwrightCapability: opts.playwrightCapability,
+    bgBashPort: opts.bgBashPort,
+    autoContinue: opts.autoContinue,
+    visualTools: opts.visualTools,
+    fileDeliveryTools: opts.fileDeliveryTools,
+    depth: opts.depth,
+    enabled: opts.mcpEnabled,
+    extra: opts.mcpExtra,
+    silent: opts.silent,
+    peerBridge: opts.peerBridge
+  });
 }
 
 // ../../packages/core/src/agents/execution-host.ts
@@ -3218,12 +3415,6 @@ async function* claudeProvider(opts) {
         const m = message;
         if (m.subtype === "init") {
           yield { type: "session", sessionId: m.session_id };
-        } else if (m.subtype === "task_started") {
-          const t = m;
-          if (t.subagent_type && !t.skip_transcript) {
-            const desc = t.description ? ` ${t.description.slice(0, 60)}` : "";
-            yield { type: "status", content: `\u25B6 [${t.subagent_type}]${desc}` };
-          }
         } else {
           logger.debug({ subtype: m.subtype, msg: m }, "claudeProvider: system message (unhandled subtype)");
         }
@@ -3307,7 +3498,8 @@ async function* claudeProvider(opts) {
           yield {
             type: "tool_result",
             toolUseId: trBlock.tool_use_id || "",
-            content: trContent
+            content: trContent,
+            ...trBlock.is_error ? { isError: true } : {}
           };
         }
       }
@@ -3321,39 +3513,98 @@ async function* claudeProvider(opts) {
 }
 
 // ../../packages/core/src/agents/codex-provider.ts
-import { existsSync as existsSync10 } from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
+import { existsSync as existsSync10, readFileSync as readFileSync8, realpathSync as realpathSync3, statSync as statSync3 } from "fs";
+import { isAbsolute, relative, resolve as resolve6 } 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 as randomUUID2 } from "crypto";
 import {
   chmodSync as chmodSync3,
+  copyFileSync,
   existsSync as existsSync9,
+  mkdtempSync,
   readFileSync as readFileSync7,
   renameSync as renameSync4,
+  rmSync,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync5
 } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname6, join as join11 } from "path";
+import { tmpdir } from "os";
+import { dirname as dirname7, join as join11 } from "path";
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.1.28";
+var NEGOTIUM_VERSION = "0.1.30";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
-var NEGOTIUM_MODEL_CATALOG = "negotium-model-catalog.json";
 var moduleRequire = createRequire(import.meta.url);
+var codexSdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
+var codexSdkRequire = createRequire(codexSdkPackagePath);
+var bundledCodexPackagePath = codexSdkRequire.resolve("@openai/codex/package.json");
+function readPackageVersion(packageJsonPath) {
+  const parsed = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+  if (typeof parsed.version !== "string" || !parsed.version.trim()) {
+    throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
+  }
+  return parsed.version;
+}
+var BUNDLED_CODEX_VERSION = readPackageVersion(bundledCodexPackagePath);
+var SAFE_BUNDLED_CODEX_VERSION = BUNDLED_CODEX_VERSION.replace(/[^a-zA-Z0-9._-]/g, "_");
+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() {
-  const sdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
-  const sdkRequire = createRequire(sdkPackagePath);
-  return join11(dirname6(sdkRequire.resolve("@openai/codex/package.json")), "bin", "codex.js");
+  return join11(dirname7(bundledCodexPackagePath), "bin", "codex.js");
+}
+function parseCodexModelCache(contents, sourcePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    throw new Error(`Codex model cache is invalid JSON: ${sourcePath}`, { cause: error });
+  }
+  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
+    throw new Error(`Codex model cache has no models: ${sourcePath}`);
+  }
+  return parsed;
+}
+function readCodexModelCache(cachePath) {
+  const contents = readFileSync7(cachePath, "utf8");
+  return { contents, parsed: parseCodexModelCache(contents, cachePath) };
+}
+function readCompatibleCodexModelCache(cachePath) {
+  const cache = readCodexModelCache(cachePath);
+  if (cache.parsed.client_version !== BUNDLED_CODEX_VERSION) {
+    const found = typeof cache.parsed.client_version === "string" ? cache.parsed.client_version : "missing or invalid";
+    throw new Error(`Codex model cache version ${found} does not match Negotium's bundled Codex ${BUNDLED_CODEX_VERSION}: ${cachePath}`);
+  }
+  return cache;
+}
+function writePrivateFileAtomic(path, contents) {
+  if (existsSync9(path) && readFileSync7(path, "utf8") === contents)
+    return;
+  const tempPath = `${path}.${process.pid}.${randomUUID2()}.tmp`;
+  try {
+    writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
+    renameSync4(tempPath, path);
+    chmodSync3(path, 384);
+  } finally {
+    try {
+      unlinkSync8(tempPath);
+    } catch {}
+  }
+}
+function bundledCodexModelCachePath(authFilePath) {
+  return join11(dirname7(authFilePath), NEGOTIUM_MODEL_CACHE);
 }
 async function bootstrapCodexModelCache(codexHome, cachePath) {
   const child = spawn3(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
     env: { ...process.env, CODEX_HOME: codexHome },
     stdio: ["pipe", "pipe", "pipe"]
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     let settled = false;
     let stdoutBuffer = "";
     let stderr = "";
@@ -3372,7 +3623,7 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
       else if (!existsSync9(cachePath))
         reject(new Error("Codex did not create its model cache"));
       else
-        resolve5();
+        resolve6();
     };
     const send = (message) => {
       child.stdin.write(`${JSON.stringify(message)}
@@ -3430,25 +3681,59 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
     });
   });
 }
+async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
+  const sourceHome = dirname7(authFilePath);
+  const isolatedHome = mkdtempSync(join11(tmpdir(), "negotium-codex-models-"));
+  const isolatedCachePath = join11(isolatedHome, "models_cache.json");
+  try {
+    const isolatedAuthPath = join11(isolatedHome, "auth.json");
+    copyFileSync(authFilePath, isolatedAuthPath);
+    chmodSync3(isolatedAuthPath, 384);
+    const sourceConfigPath = join11(sourceHome, "config.toml");
+    if (existsSync9(sourceConfigPath)) {
+      const isolatedConfigPath = join11(isolatedHome, "config.toml");
+      copyFileSync(sourceConfigPath, isolatedConfigPath);
+      chmodSync3(isolatedConfigPath, 384);
+    }
+    await bootstrap(isolatedHome, isolatedCachePath);
+    return readCompatibleCodexModelCache(isolatedCachePath).contents;
+  } finally {
+    rmSync(isolatedHome, { recursive: true, force: true });
+  }
+}
 async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
-  const codexHome = dirname6(authFilePath);
-  const cachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? join11(codexHome, "models_cache.json");
-  const hardenedCatalogPath = join11(codexHome, NEGOTIUM_MODEL_CATALOG);
-  if (existsSync9(cachePath) || existsSync9(hardenedCatalogPath))
-    return;
-  if (process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE) {
-    throw new Error(`Configured Codex model cache does not exist: ${cachePath}`);
+  const codexHome = dirname7(authFilePath);
+  const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
+  if (configuredCachePath) {
+    if (!existsSync9(configuredCachePath)) {
+      throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
+    }
+    readCompatibleCodexModelCache(configuredCachePath);
+    return configuredCachePath;
+  }
+  const bundledCachePath = bundledCodexModelCachePath(authFilePath);
+  const sharedCachePath = join11(codexHome, "models_cache.json");
+  if (existsSync9(sharedCachePath)) {
+    try {
+      const shared = readCompatibleCodexModelCache(sharedCachePath);
+      writePrivateFileAtomic(bundledCachePath, shared.contents);
+      return bundledCachePath;
+    } catch {}
+  }
+  if (existsSync9(bundledCachePath)) {
+    try {
+      readCompatibleCodexModelCache(bundledCachePath);
+      return bundledCachePath;
+    } catch {}
   }
-  await bootstrap(codexHome, cachePath);
+  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
+  writePrivateFileAtomic(bundledCachePath, refreshedContents);
+  return bundledCachePath;
 }
-function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath) {
-  const codexHome = dirname6(authFilePath);
-  const sourcePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? (existsSync9(join11(codexHome, "models_cache.json")) ? join11(codexHome, "models_cache.json") : join11(codexHome, NEGOTIUM_MODEL_CATALOG));
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
+  const codexHome = dirname7(authFilePath);
   const outputPath = join11(codexHome, NEGOTIUM_MODEL_CATALOG);
-  const parsed = JSON.parse(readFileSync7(sourcePath, "utf8"));
-  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
-    throw new Error(`Codex model cache has no models: ${sourcePath}`);
-  }
+  const parsed = readCodexModelCache(sourcePath).parsed;
   const models = parsed.models.map((model, index) => {
     if (!model || typeof model !== "object" || Array.isArray(model)) {
       throw new Error(`Codex model cache entry ${index} is invalid: ${sourcePath}`);
@@ -3457,22 +3742,56 @@ function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath) {
   });
   const contents = `${JSON.stringify({ models }, null, 2)}
 `;
-  if (existsSync9(outputPath) && readFileSync7(outputPath, "utf8") === contents) {
-    return outputPath;
-  }
-  const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
-  try {
-    writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
-    renameSync4(tempPath, outputPath);
-    chmodSync3(outputPath, 384);
-  } finally {
-    try {
-      unlinkSync8(tempPath);
-    } catch {}
-  }
+  writePrivateFileAtomic(outputPath, contents);
   return outputPath;
 }
 
+// ../../packages/core/src/agents/tool-format.ts
+import { diffLines as computeLineDiff } from "diff";
+function changedDiffLines(value) {
+  const lines = value.split(`
+`);
+  if (lines.at(-1) === "")
+    lines.pop();
+  return lines;
+}
+function buildNumberedDiffSummary(before, after, startLine = 1) {
+  const removed = [];
+  const added = [];
+  const preview = [];
+  let oldLine = startLine;
+  let newLine = startLine;
+  for (const part of computeLineDiff(before, after)) {
+    const lines = changedDiffLines(part.value);
+    if (part.removed) {
+      for (const line of lines) {
+        removed.push(line);
+        preview.push(`${oldLine} -${line}`);
+        oldLine += 1;
+      }
+      continue;
+    }
+    if (part.added) {
+      for (const line of lines) {
+        added.push(line);
+        preview.push(`${newLine} +${line}`);
+        newLine += 1;
+      }
+      continue;
+    }
+    oldLine += lines.length;
+    newLine += lines.length;
+  }
+  return {
+    ...removed.length > 0 ? { before: removed.join(`
+`) } : {},
+    ...added.length > 0 ? { after: added.join(`
+`) } : {},
+    ...preview.length > 0 ? { diffPreview: preview.join(`
+`) } : {}
+  };
+}
+
 // ../../packages/core/src/agents/codex-provider.ts
 function mapEffort(effort) {
   if (!effort)
@@ -3555,22 +3874,142 @@ function summarizeMcpToolCallResult(item) {
     return text.slice(0, 200);
   return JSON.stringify(item.result.structured_content ?? "").slice(0, 200);
 }
-function fileChangeEvents(item) {
+var CODEX_DIFF_FILE_LIMIT = 512 * 1024;
+var CODEX_DIFF_BASELINE_FILE_LIMIT = 200;
+var CODEX_DIFF_BASELINE_BYTE_LIMIT = 16 * 1024 * 1024;
+function canonicalPath(path) {
+  try {
+    return realpathSync3(resolve6(path));
+  } catch {
+    return resolve6(path);
+  }
+}
+function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
+  if (!existsSync10(path))
+    return null;
+  try {
+    const byteLimit = Math.min(CODEX_DIFF_FILE_LIMIT, Math.max(0, maxBytes));
+    if (statSync3(path).size > byteLimit)
+      return;
+    const content = readFileSync8(path);
+    if (content.byteLength > byteLimit || content.includes(0))
+      return;
+    return content.toString("utf8");
+  } catch {
+    return;
+  }
+}
+
+class CodexFilePreviewTracker {
+  #cwd;
+  #root;
+  #baseline = new Map;
+  #baselineAvailable = false;
+  constructor(cwd) {
+    this.#cwd = canonicalPath(cwd);
+    const root = this.#git(["rev-parse", "--show-toplevel"], this.#cwd)?.trim();
+    this.#root = root ? canonicalPath(root) : null;
+    if (!this.#root)
+      return;
+    const status = this.#git(["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    if (status === undefined)
+      return;
+    this.#baselineAvailable = true;
+    let loadedFiles = 0;
+    let loadedBytes = 0;
+    const records = status.split("\x00");
+    for (let index = 0;index < records.length; index += 1) {
+      const record = records[index];
+      if (!record || record.length < 4)
+        continue;
+      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(resolve6(this.#root, path), remainingBytes) : undefined;
+      this.#baseline.set(path, content);
+      if (typeof content === "string") {
+        loadedFiles += 1;
+        loadedBytes += Buffer.byteLength(content);
+      }
+      if (/[RC]/.test(code))
+        index += 1;
+    }
+  }
+  preview(path, succeeded) {
+    if (!this.#root || !this.#baselineAvailable || !succeeded)
+      return {};
+    const absolute = canonicalPath(isAbsolute(path) ? path : resolve6(this.#cwd, path));
+    const relativePath = relative(this.#root, absolute);
+    if (!relativePath || relativePath.startsWith("..") || isAbsolute(relativePath))
+      return {};
+    const before = this.#baseline.has(relativePath) ? this.#baseline.get(relativePath) : this.#headFile(relativePath);
+    const after = textFile(absolute);
+    this.#baseline.set(relativePath, after);
+    if (before === undefined || after === undefined)
+      return {};
+    const diff = buildNumberedDiffSummary(before ?? "", after ?? "");
+    return {
+      ...diff.before !== undefined ? { before: diff.before } : {},
+      ...diff.after !== undefined ? { after: diff.after } : {},
+      ...diff.diffPreview !== undefined ? { diff_preview: diff.diffPreview } : {}
+    };
+  }
+  #headFile(path) {
+    const content = this.#git(["show", `HEAD:${path}`]);
+    if (content === undefined)
+      return null;
+    return Buffer.byteLength(content) > CODEX_DIFF_FILE_LIMIT || content.includes("\x00") ? undefined : content;
+  }
+  #git(args, cwd = this.#root ?? undefined) {
+    try {
+      return execFileSync5("git", ["-C", cwd ?? ".", ...args], {
+        encoding: "utf8",
+        maxBuffer: CODEX_DIFF_FILE_LIMIT * 4,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    } catch {
+      return;
+    }
+  }
+}
+async function fileChangeEvents(item, previews, cwd, threadId, consumedPatchCallIds) {
+  const expectedPaths = item.changes.map((change) => isAbsolute(change.path) ? change.path : resolve6(cwd, change.path));
+  let nativePreview;
+  if (threadId && item.status === "completed") {
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, 20));
+    nativePreview = readLatestCodexPatchPreview(threadId, expectedPaths, consumedPatchCallIds);
+  }
+  for (const delayMs of [20, 40, 80, 120]) {
+    if (nativePreview || !threadId || item.status !== "completed")
+      break;
+    await new Promise((resolveDelay) => setTimeout(resolveDelay, delayMs));
+    nativePreview = readLatestCodexPatchPreview(threadId, expectedPaths, consumedPatchCallIds);
+  }
+  if (nativePreview)
+    consumedPatchCallIds.add(nativePreview.callId);
   return item.changes.flatMap((change, index) => {
     const name = change.kind === "add" ? "Write" : change.kind === "delete" ? "Delete" : "Edit";
     const toolUseId = `${item.id}:${index}`;
     const success = item.status === "completed";
+    const nativeChange = nativePreview?.changes[index];
+    const fallbackPreview = previews.preview(change.path, success);
+    const preview = success && nativeChange ? {
+      ...nativeChange.before !== undefined ? { before: nativeChange.before } : {},
+      ...nativeChange.after !== undefined ? { after: nativeChange.after } : {},
+      ...nativeChange.diffPreview !== undefined ? { diff_preview: nativeChange.diffPreview } : {}
+    } : fallbackPreview;
     return [
       {
         type: "tool_use",
         name,
-        input: { file_path: change.path, change_kind: change.kind },
+        input: { file_path: change.path, change_kind: change.kind, ...preview },
         toolUseId
       },
       {
         type: "tool_result",
         toolUseId,
-        content: success ? `${change.kind} applied: ${change.path}` : `${change.kind} failed: ${change.path}`
+        content: success ? `${change.kind} applied: ${change.path}` : `${change.kind} failed: ${change.path}`,
+        ...success ? {} : { isError: true }
       }
     ];
   });
@@ -3656,6 +4095,8 @@ function prependFirstEvent(iter, firstEvent, alreadyDone) {
   };
 }
 async function* codexProvider(opts) {
+  const filePreviews = new CodexFilePreviewTracker(opts.cwd);
+  const consumedPatchCallIds = new Set(opts.sessionId ? readCodexPatchCallIds(opts.sessionId) : []);
   const codexAuthPath = hostedCodexAuthFilePath();
   if (!existsSync10(codexAuthPath)) {
     yield {
@@ -3666,8 +4107,8 @@ async function* codexProvider(opts) {
   }
   let codexModelCatalogPath;
   try {
-    await ensureCodexModelCache(codexAuthPath);
-    codexModelCatalogPath = writeCodexCatalogWithNativeMultiAgentDisabled(codexAuthPath);
+    const codexModelCachePath = await ensureCodexModelCache(codexAuthPath);
+    codexModelCatalogPath = writeCodexCatalogWithNativeMultiAgentDisabled(codexAuthPath, codexModelCachePath);
     if (opts.sessionId)
       migrateCodexRolloutNativeMultiAgentMetadata(opts.sessionId);
   } catch (err) {
@@ -3790,10 +4231,11 @@ async function* codexProvider(opts) {
               if (!item)
                 break;
               if (item.type === "command_execution") {
+                const command = String(item.command ?? "");
                 yield {
                   type: "tool_use",
                   name: "Bash",
-                  input: { command: String(item.command ?? "") },
+                  input: { command },
                   toolUseId: String(item.id ?? "")
                 };
               } else if (item.type === "mcp_tool_call") {
@@ -3839,19 +4281,24 @@ async function* codexProvider(opts) {
                 if (reasoning)
                   yield { type: "reasoning", content: reasoning };
               } else if (item.type === "mcp_tool_call") {
+                const isError = item.status === "failed" || Boolean(item.error);
                 yield {
                   type: "tool_result",
                   toolUseId: String(item.id ?? ""),
-                  content: summarizeMcpToolCallResult(item)
+                  content: summarizeMcpToolCallResult(item),
+                  ...isError ? { isError: true } : {}
                 };
               } else if (item.type === "command_execution") {
+                const isError = item.status === "failed" || typeof item.exit_code === "number" && item.exit_code !== 0;
                 yield {
                   type: "tool_result",
                   toolUseId: String(item.id ?? ""),
-                  content: String(item.aggregated_output ?? "").slice(0, 200)
+                  content: String(item.aggregated_output ?? "").slice(0, 200),
+                  ...isError ? { isError: true } : {}
                 };
               } else if (item.type === "file_change") {
-                for (const fileEvent of fileChangeEvents(item)) {
+                const fileEvents = await fileChangeEvents(item, filePreviews, opts.cwd, currentSessionId, consumedPatchCallIds);
+                for (const fileEvent of fileEvents) {
                   yield fileEvent;
                 }
               } else if (item.type === "error") {
@@ -4000,6 +4447,18 @@ function providerOwnedToolRedirect(toolName) {
   }
   return "Use the shared task MCP tools instead " + "(mcp__task__task_create / task_update / task_list / task_get / task_delete).";
 }
+function resolveMaestroApiKeyOverrides(userId) {
+  if (!userId)
+    return;
+  const deepseek = vaultGetValue(userId, "DEEPSEEK_API_KEY")?.trim();
+  const moonshot = vaultGetValue(userId, "MOONSHOT_API_KEY")?.trim();
+  if (!deepseek && !moonshot)
+    return;
+  return {
+    ...deepseek ? { deepseek } : {},
+    ...moonshot ? { moonshot } : {}
+  };
+}
 function buildProviderOwnedToolBlockHook() {
   return {
     name: "provider-owned-tool-redirect",
@@ -4026,6 +4485,7 @@ function maestroProvider(opts) {
     maxTokens: MAESTRO_DEFAULT_MAX_TOKENS,
     enableToolSearch: true,
     ...opts,
+    apiKeyOverrides: resolveMaestroApiKeyOverrides(userId),
     agent: "maestro",
     disallowedTools: buildMaestroDisallowedTools(callerDisallowedTools),
     toolHooks: [...buildMaestroToolHooks(userId), ...callerToolHooks]
@@ -4034,8 +4494,8 @@ function maestroProvider(opts) {
 }
 
 // ../../packages/core/src/storage/tasks.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync8, renameSync as renameSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname7, join as join12 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync9, renameSync as renameSync5, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, join as join12 } from "path";
 function safeUserIdComponent2(userId) {
   const str = String(userId);
   if (!str || /[/\\]|\.\./.test(str)) {
@@ -4061,7 +4521,7 @@ function readTasks(userId, scopeKey) {
   if (!existsSync11(path))
     return [];
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
     return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
   } catch (e) {
     logger.warn({ err: e, path }, "tasks: failed to read task store");
@@ -4070,7 +4530,7 @@ function readTasks(userId, scopeKey) {
 }
 function taskFileMtimeNs(userId, scopeKey) {
   try {
-    return statSync3(getTaskFilePath(userId, scopeKey), { bigint: true }).mtimeNs;
+    return statSync4(getTaskFilePath(userId, scopeKey), { bigint: true }).mtimeNs;
   } catch {
     return null;
   }
@@ -4207,7 +4667,7 @@ async function* runAgent(opts) {
 }
 
 // ../../packages/core/src/bus.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // ../../packages/core/src/storage/forum-db.ts
 var db = internalStorageDatabase;
@@ -4288,7 +4748,7 @@ class SqliteRuntimeBus {
   pollTimer = null;
   polling = false;
   constructor(options = {}) {
-    this.sourceId = options.sourceId ?? `${process.pid}-${randomUUID2()}`;
+    this.sourceId = options.sourceId ?? `${process.pid}-${randomUUID3()}`;
     this.pollIntervalMs = Math.max(25, options.pollIntervalMs ?? 100);
     this.cursor = latestRuntimeEventSeq();
   }
@@ -4391,9 +4851,15 @@ class SqliteRuntimeBus {
       toolUseId: id
     });
   }
-  broadcastToolOutput(topicId, queryId, toolUseId, content) {
+  broadcastToolOutput(topicId, queryId, toolUseId, content, isError) {
     const id = toolUseId.trim() || `${queryId}:tool`;
-    this.broadcastAiStatus(topicId, { kind: "tool_output", queryId, toolUseId: id, content });
+    this.broadcastAiStatus(topicId, {
+      kind: "tool_output",
+      queryId,
+      toolUseId: id,
+      content,
+      ...isError ? { isError: true } : {}
+    });
   }
   broadcastToolStatus(topicId, queryId, kind, content, meta) {
     this.broadcastAiStatus(topicId, {
@@ -4435,8 +4901,8 @@ var WsHub = {
 };
 
 // ../../packages/core/src/prompts/builders.ts
-import { readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve7 } from "path";
 
 // ../../packages/core/src/agents/model-catalog.ts
 var CODEX_PRO_20X_COST = "ChatGPT Pro 20x subscription: $200/month";
@@ -4537,10 +5003,10 @@ var SELECTABLE_MODELS = [
 ];
 
 // ../../packages/core/src/prompts/builders.ts
-var PROMPTS_DIR = resolve5(PROJECT_ROOT, "src/prompts");
-var SESSIONS_DIR = resolve5(PROMPTS_DIR, "sessions");
+var PROMPTS_DIR = resolve7(PROJECT_ROOT, "src/prompts");
+var SESSIONS_DIR = resolve7(PROMPTS_DIR, "sessions");
 function loadAgentPrompt(filename) {
-  const raw = readFileSync9(resolve5(AGENTS_PROMPTS_DIR, filename), "utf-8");
+  const raw = readFileSync10(resolve7(AGENTS_PROMPTS_DIR, filename), "utf-8");
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match)
     throw new Error(`Agent prompt ${filename} is missing frontmatter`);
@@ -4721,7 +5187,7 @@ function setTopicBrief(topicId, fields) {
 }
 
 // ../../packages/core/src/storage/wiki.ts
-import { basename, dirname as dirname8, join as join14 } from "path";
+import { basename as basename2, dirname as dirname9, join as join14 } from "path";
 function getSharedWikiDir(workspaceDir = resolveStorageWorkspaceDir()) {
   return workspaceDir === resolveStorageWorkspaceDir() ? resolveStorageSharedWikiDir() : join14(workspaceDir, "wiki");
 }
@@ -4741,7 +5207,7 @@ function wikiSummaryFilename(date, rawTopic, topicId) {
 }
 
 // ../../packages/core/src/topics/personal-general.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // ../../packages/core/src/platform/constants.ts
 var FROM_AUTO_CONTINUE = "auto-continue";
@@ -5250,7 +5716,7 @@ function ensurePersonalGeneral(userId) {
   const now = new Date().toISOString();
   const registry = getRegistry("maestro");
   const topic = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     title: "General",
     description: PERSONAL_GENERAL_DESCRIPTION,
     kind: "manager",
@@ -5336,7 +5802,7 @@ function runArchiverTurn(params) {
     mcpEnabled: ["wiki"],
     silent: true
   });
-  const activeSessionId = `memory:${randomUUID4()}`;
+  const activeSessionId = `memory:${randomUUID5()}`;
   activeArchiverSessions.set(activeSessionId, {
     id: activeSessionId,
     kind: "memory",
@@ -5445,7 +5911,7 @@ function findSummaryFile(topicTitle, date, sinceMs, topicId) {
       continue;
     const p = join15(dir, f);
     try {
-      const m = statSync4(p).mtimeMs;
+      const m = statSync5(p).mtimeMs;
       if (m >= sinceMs && (!best || m > best.mtime))
         best = { path: p, mtime: m };
     } catch {}
@@ -5457,7 +5923,7 @@ function finalizeGeneralMemory(userId, topicTitle, messageCount, startMs, ok, to
   const date = new Date().toISOString().slice(0, 10);
   try {
     const summaryPath = ok ? findSummaryFile(topicTitle, date, startMs, topicId) : null;
-    const summaryMd = summaryPath ? readFileSync10(summaryPath, "utf-8") : "";
+    const summaryMd = summaryPath ? readFileSync11(summaryPath, "utf-8") : "";
     const oneLine = summaryMd && distillOneLine(summaryMd) || `${messageCount}\uAC1C \uBA54\uC2DC\uC9C0 \uC544\uCE74\uC774\uBE0C`;
     const prev = getTopicBrief(generalTopicId);
     const prevEntries = (prev?.briefMd ?? "").split(`
@@ -5492,7 +5958,7 @@ ${rolled.join(`
       usage: generalReply.usage
     } : { authorId: "system" };
     const msg = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       topicId: generalTopicId,
       text,
       ...replyMeta,
@@ -5526,7 +5992,7 @@ function countMemoryArchiveExchanges(rows) {
 }
 
 // ../../packages/core/src/storage/runtime-leases.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // ../../packages/core/src/storage/runtime-topic-state.ts
 var TOPIC_MAINTENANCE_STALE_MS = 30000;
@@ -5541,7 +6007,7 @@ db.exec(`
 `);
 
 // ../../packages/core/src/storage/runtime-leases.ts
-var RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID5()}`;
+var RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID6()}`;
 var TURN_LEASE_STALE_MS = 1e4;
 db.exec(`
   CREATE TABLE IF NOT EXISTS runtime_turn_leases (
@@ -6020,7 +6486,7 @@ function archiveTopicMessages(topicId, topicTitle, options = {}) {
 }
 
 // ../../packages/core/src/storage/topic-archive-state.ts
-import { rmSync } from "fs";
+import { rmSync as rmSync2 } from "fs";
 registerStorageSchemaInitializer((database) => {
   database.exec(`
     CREATE TABLE IF NOT EXISTS api_topic_archive_state (
@@ -6121,7 +6587,7 @@ function claimTopicArchiveJob(topicId, create, now = Date.now()) {
     })();
     if (result.kind === "claimed")
       return result;
-    rmSync(candidate.archivePath, { force: true });
+    rmSync2(candidate.archivePath, { force: true });
     if (result.kind === "busy")
       return result;
   }
@@ -6417,4 +6883,4 @@ export {
   MIN_MEMORY_ARCHIVE_EXCHANGES
 };
 
-//# debugId=34EC4A567FFF49C164756E2164756E21
+//# debugId=CC442F5FF6F506FC64756E2164756E21