negotium 0.1.28 → 0.1.29

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 { randomBytes as randomBytes3 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } 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 [
@@ -1102,18 +1388,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 +1443,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 +1564,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 +1581,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 +1605,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) {
@@ -1365,97 +1651,44 @@ function decodeUuidV7Timestamp(threadId) {
     return null;
   const MIN = 1577836800000;
   const MAX = 4102444800000;
-  if (ms < MIN || ms > MAX)
-    return null;
-  return ms;
-}
-function formatDateBucket(d) {
-  const yyyy = d.getUTCFullYear();
-  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
-  const dd = String(d.getUTCDate()).padStart(2, "0");
-  return `${yyyy}/${mm}/${dd}`;
-}
-
-// ../../packages/core/src/storage/conversations.ts
-import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync5,
-  renameSync as renameSync3,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync4
-} from "fs";
-import { dirname as dirname5, join as join8 } from "path";
-
-// ../../packages/core/src/security/sanitize.ts
-function sanitizeTopicName(name, lowercase = false) {
-  const safe = name.replace(/[^a-zA-Z0-9\uAC00-\uD7A3_-]/g, "_") || "_";
-  return lowercase ? safe.toLowerCase() : safe;
-}
-function sanitizeFileName(name) {
-  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_") || "_";
-  if (safe === "." || safe === "..")
-    return "_";
-  return safe;
-}
-
-// ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync5 } 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;
+  if (ms < MIN || ms > MAX)
+    return null;
+  return ms;
+}
+function formatDateBucket(d) {
+  const yyyy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  return `${yyyy}/${mm}/${dd}`;
+}
+
+// ../../packages/core/src/storage/conversations.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { dirname as dirname5, join as join9 } from "path";
+
+// ../../packages/core/src/security/sanitize.ts
+function sanitizeTopicName(name, lowercase = false) {
+  const safe = name.replace(/[^a-zA-Z0-9\uAC00-\uD7A3_-]/g, "_") || "_";
+  return lowercase ? safe.toLowerCase() : safe;
+}
+function sanitizeFileName(name) {
+  const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_") || "_";
+  if (safe === "." || safe === "..")
+    return "_";
+  return safe;
 }
 
 // ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname as dirname4, join as join8, resolve as resolve3 } from "path";
 var configuredHost = {};
 var fallbackDatabase = null;
 var fallbackDatabasePath = null;
@@ -1467,16 +1700,16 @@ function envPath(name, fallback) {
   return resolve3(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 +1726,7 @@ function defaultDatabase() {
     return fallbackDatabase;
   if (fallbackDatabase)
     fallbackDatabase.close();
-  mkdirSync5(dirname4(path), { recursive: true });
+  mkdirSync6(dirname4(path), { recursive: true });
   fallbackDatabase = new Database(path, { create: true });
   fallbackDatabasePath = path;
   initializeDatabase(fallbackDatabase);
@@ -1509,7 +1742,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 +1796,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 +1819,7 @@ function appendConversationEventStrict(userId, topicName, agent, event) {
     agent,
     event
   };
-  mkdirSync6(dirname5(path), { recursive: true });
+  mkdirSync7(dirname5(path), { recursive: true });
   appendJsonlLine(path, JSON.stringify(entry));
 }
 function readConversation(userId, topicName) {
@@ -1655,13 +1888,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,7 +1980,7 @@ function cleanupAgentFork(handle) {
   defaultForkHelpers.cleanupAgentFork(handle);
 }
 // ../../packages/core/src/agents/archiver.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
 import { join as join15 } from "path";
 
@@ -1932,8 +2165,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 +2183,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 +2194,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;
@@ -2201,23 +2434,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) {
@@ -2610,175 +2843,6 @@ function getMcpServersForQuery(opts) {
   });
 }
 
-// ../../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)
-  }));
-}
-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/execution-host.ts
 var defaultHost = {
   getMcpServersForQuery,
@@ -3218,12 +3282,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)");
         }
@@ -3326,27 +3384,84 @@ 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 { tmpdir } from "os";
 import { dirname as dirname6, join as join11 } from "path";
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.1.28";
+var NEGOTIUM_VERSION = "0.1.29";
 
 // ../../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(dirname6(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(dirname6(authFilePath), NEGOTIUM_MODEL_CACHE);
 }
 async function bootstrapCodexModelCache(codexHome, cachePath) {
   const child = spawn3(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
@@ -3430,25 +3545,59 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
     });
   });
 }
+async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
+  const sourceHome = dirname6(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 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 {}
   }
-  await bootstrap(codexHome, cachePath);
+  if (existsSync9(bundledCachePath)) {
+    try {
+      readCompatibleCodexModelCache(bundledCachePath);
+      return bundledCachePath;
+    } catch {}
+  }
+  const refreshedContents = await bootstrapIsolatedCodexModelCache(authFilePath, bootstrap);
+  writePrivateFileAtomic(bundledCachePath, refreshedContents);
+  return bundledCachePath;
 }
-function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath) {
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath, sourcePath) {
   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));
   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,19 +3606,7 @@ 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;
 }
 
@@ -3666,8 +3803,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) {
@@ -4000,6 +4137,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 +4175,7 @@ function maestroProvider(opts) {
     maxTokens: MAESTRO_DEFAULT_MAX_TOKENS,
     enableToolSearch: true,
     ...opts,
+    apiKeyOverrides: resolveMaestroApiKeyOverrides(userId),
     agent: "maestro",
     disallowedTools: buildMaestroDisallowedTools(callerDisallowedTools),
     toolHooks: [...buildMaestroToolHooks(userId), ...callerToolHooks]
@@ -4207,7 +4357,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 +4438,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();
   }
@@ -4741,7 +4891,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 +5400,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 +5486,7 @@ function runArchiverTurn(params) {
     mcpEnabled: ["wiki"],
     silent: true
   });
-  const activeSessionId = `memory:${randomUUID4()}`;
+  const activeSessionId = `memory:${randomUUID5()}`;
   activeArchiverSessions.set(activeSessionId, {
     id: activeSessionId,
     kind: "memory",
@@ -5492,7 +5642,7 @@ ${rolled.join(`
       usage: generalReply.usage
     } : { authorId: "system" };
     const msg = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       topicId: generalTopicId,
       text,
       ...replyMeta,
@@ -5526,7 +5676,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 +5691,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 +6170,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 +6271,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 +6567,4 @@ export {
   MIN_MEMORY_ARCHIVE_EXCHANGES
 };
 
-//# debugId=34EC4A567FFF49C164756E2164756E21
+//# debugId=A260F0394930433E64756E2164756E21