negotium 0.1.12 → 0.1.13

package/dist/hosted-agent.js

@@ -1,22 +1,3017 @@
 // @bun
 import {
-  claudeProvider,
-  codexProvider,
-  configureAgentExecutionHost,
-  maestroProvider,
-  resolveAgentExecutionHost,
-  transformHostedQueryOptions,
-  withAgentExecutionHost
-} from "./chunk-00q25k7p.js";
-import"./chunk-gaknyw04.js";
-import"./chunk-mh5mexsf.js";
-import"./chunk-ezs352qs.js";
-import {
+  __require,
+  __toESM,
+  canonicalMcpBridgeEnv,
   revokeCanonicalMcpBridgeTurn
-} from "./chunk-j0kjscb7.js";
-import"./chunk-ffefbd3r.js";
-import"./chunk-f5xgprg1.js";
-import"./chunk-hwy3n31w.js";
+} from "./chunk-s2gez3wg.js";
+
+// ../../packages/core/src/agents/claude-provider.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// ../../packages/core/src/agents/claude-registry.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readdirSync, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+
+// ../../packages/core/src/agents/rollout/claude.ts
+import { randomUUID } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// ../../packages/core/src/agents/rollout/shared.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../../packages/core/src/platform/config.ts
+import { randomBytes } from "crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// ../../packages/core/src/platform/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env.LOG_LEVEL || "info",
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      translateTime: "SYS:yyyy-mm-dd HH:MM:ss",
+      destination: 2
+    }
+  }
+}, pino.destination(2));
+
+// ../../packages/core/src/types.ts
+var SUPPORTED_AGENTS = ["maestro", "claude", "codex"];
+function isAgentKind(value) {
+  return typeof value === "string" && SUPPORTED_AGENTS.includes(value);
+}
+var CLAUDE_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max"];
+
+// ../../packages/core/src/platform/config.ts
+function envText(envKey) {
+  const value = process.env[envKey]?.trim();
+  return value ? value : undefined;
+}
+function resolveAgentEnv(envKey, fallback, legacyEnvKey) {
+  const value = envText(envKey) ?? (legacyEnvKey ? envText(legacyEnvKey) : undefined);
+  return isAgentKind(value) ? value : fallback;
+}
+var HOME = homedir();
+function resolveProjectRoot() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const packagedRuntime = resolve(moduleDir, "runtime");
+  if (existsSync(resolve(packagedRuntime, "src")))
+    return packagedRuntime;
+  return resolve(moduleDir, "../..");
+}
+var PROJECT_ROOT = resolveProjectRoot();
+function resolveDependencyBin(name) {
+  let dir = PROJECT_ROOT;
+  while (true) {
+    const candidate = resolve(dir, "node_modules", ".bin", name);
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return candidate;
+    dir = parent;
+  }
+}
+var STATE_DIR_ENV = envText("NEGOTIUM_STATE_DIR");
+var STATE_DIR = STATE_DIR_ENV ? resolve(STATE_DIR_ENV) : resolve(HOME, ".negotium");
+function resolveLocalStateDir(envKey, stateName) {
+  const envValue = envText(envKey);
+  if (envValue)
+    return resolve(envValue);
+  return resolve(STATE_DIR, stateName);
+}
+function parsePortEnv(envValue, fallback) {
+  if (!envValue)
+    return fallback;
+  const port = Number.parseInt(envValue, 10);
+  return Number.isInteger(port) && port > 0 ? port : fallback;
+}
+var WORKSPACE_DIR = resolveLocalStateDir("NEGOTIUM_WORKSPACE_DIR", "workspace");
+var TOPIC_WORKSPACE_DIR = resolve(WORKSPACE_DIR, "topics");
+var SHARED_WIKI_DIR = resolve(WORKSPACE_DIR, "wiki");
+var 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");
+function resolveBrowserMcpBin(envValue) {
+  const override = envValue?.trim();
+  if (override) {
+    if (!/(^|\/)(mcp-patchright|mcp-patchright-http\.mjs)$/.test(override)) {
+      throw new Error("NEGOTIUM_BROWSER_MCP_BIN must point to the authenticated mcp-patchright wrapper.");
+    }
+    return override;
+  }
+  return PATCHRIGHT_MCP_BIN;
+}
+var PATCHRIGHT_MCP_BIN = resolve(PROJECT_ROOT, "scripts/mcp-patchright-http.mjs");
+var PLAYWRIGHT_MCP_BIN = resolveBrowserMcpBin(envText("NEGOTIUM_BROWSER_MCP_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 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 PADDLEOCR_SERVER = resolve(PROJECT_ROOT, "src/mcp/paddleocr-server.ts");
+var TOKEN_STATS_SERVER = resolve(PROJECT_ROOT, "src/mcp/token-stats-server.ts");
+var SYSTEM_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/system-health-server.ts");
+var AGENT_HEALTH_SERVER = resolve(PROJECT_ROOT, "src/mcp/agent-health-server.ts");
+var BACKGROUND_BASH_SERVER = resolve(PROJECT_ROOT, "src/mcp/background-bash-server.ts");
+var VAULT_SERVER = resolve(PROJECT_ROOT, "src/mcp/vault-server.ts");
+var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
+var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
+function safeWorkspaceSegment(value, fallback) {
+  const cleaned = value.trim().replace(/[^A-Za-z0-9._-]/g, "_").replace(/^_+|_+$/g, "").slice(0, 160);
+  return cleaned || fallback;
+}
+function resolveTopicWorkspaceDir(topicId) {
+  return join(TOPIC_WORKSPACE_DIR, safeWorkspaceSegment(topicId, "topic"));
+}
+function loadOrCreateLocalSecret(envKey, filename, options = {}) {
+  const envValue = envText(envKey);
+  const secretFile = resolve(STATE_DIR, filename);
+  mkdirSync(dirname(secretFile), { recursive: true });
+  if (envValue) {
+    if (options.persistEnvValue) {
+      writeFileSync(secretFile, `${envValue}
+`, { mode: 384 });
+      chmodSync(secretFile, 384);
+    }
+    return envValue;
+  }
+  if (existsSync(secretFile)) {
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (stored) {
+      chmodSync(secretFile, 384);
+      return stored;
+    }
+  }
+  const secret = randomBytes(32).toString("base64url");
+  try {
+    writeFileSync(secretFile, `${secret}
+`, { mode: 384, flag: "wx" });
+    return secret;
+  } catch (error) {
+    if (error.code !== "EEXIST")
+      throw error;
+    const stored = readFileSync(secretFile, "utf-8").trim();
+    if (!stored)
+      throw new Error(`Secret file exists but is empty: ${secretFile}`);
+    chmodSync(secretFile, 384);
+    return stored;
+  }
+}
+var RUNTIME_MCP_SECRET = loadOrCreateLocalSecret("RUNTIME_MCP_SECRET", "runtime-mcp-secret");
+var NODE_CONTROL_TOKEN = loadOrCreateLocalSecret("NEGOTIUM_CONTROL_TOKEN", "node-control-token");
+var VAULT_MASTER_KEY = loadOrCreateLocalSecret("NEGOTIUM_VAULT_MASTER_KEY", "vault-master-key", { persistEnvValue: true });
+delete process.env.NEGOTIUM_VAULT_MASTER_KEY;
+var NEGOTIUM_PORT = parseInt(process.env.NEGOTIUM_PORT || "7777", 10);
+var hostname = process.env.HOSTNAME || "127.0.0.1";
+var DATA_DIR = resolveLocalStateDir("NEGOTIUM_DATA_DIR", "data");
+var LOG_DIR = resolveLocalStateDir("NEGOTIUM_LOG_DIR", "logs");
+var SESSIONS_DB = process.env.SESSIONS_DB_PATH ? resolve(process.env.SESSIONS_DB_PATH) : resolve(DATA_DIR, "sessions.db");
+var DEBUG_FILE = resolve(DATA_DIR, "debug-users.json");
+var USERS_LOG_DIR = resolve(DATA_DIR, "users");
+var RUN_DIR = resolveLocalStateDir("NEGOTIUM_RUN_DIR", "run");
+var PROGRESS_DIR = resolve(RUN_DIR, "progress");
+var DM_CMD_DIR = resolve(RUN_DIR, "dm-commands");
+var DM_RESP_DIR = resolve(RUN_DIR, "dm-responses");
+var SESSION_INBOX_DIR = resolve(RUN_DIR, "session-inbox");
+var SESSION_ASKS_DIR = resolve(RUN_DIR, "session-asks");
+var PLAYWRIGHT_BASE_PORT = parsePortEnv(process.env.PLAYWRIGHT_BASE_PORT, 9100);
+var PLAYWRIGHT_MAX_PORT = parsePortEnv(process.env.PLAYWRIGHT_MAX_PORT, 9499);
+var PLAYWRIGHT_PORTS_DIR = resolve(RUN_DIR, "playwright-ports");
+mkdirSync(STATE_DIR, { recursive: true });
+mkdirSync(DATA_DIR, { recursive: true });
+mkdirSync(LOG_DIR, { recursive: true });
+mkdirSync(PROGRESS_DIR, { recursive: true });
+mkdirSync(DM_CMD_DIR, { recursive: true });
+mkdirSync(DM_RESP_DIR, { recursive: true });
+mkdirSync(SESSION_INBOX_DIR, { recursive: true });
+mkdirSync(SESSION_ASKS_DIR, { recursive: true });
+mkdirSync(PLAYWRIGHT_PORTS_DIR, { recursive: true });
+mkdirSync(WORKSPACE_DIR, { recursive: true });
+mkdirSync(TOPIC_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SHARED_WIKI_DIR, { recursive: true });
+mkdirSync(CONTEXTS_DIR, { recursive: true });
+mkdirSync(BROWSER_PROFILES_DIR, { recursive: true });
+mkdirSync(DM_WORKSPACE_DIR, { recursive: true });
+mkdirSync(SESSION_WORKSPACE_DIR, { recursive: true });
+var ACTIVE_QUERY_STALE_MS = 10 * 60 * 1000;
+var AGENTS_PROMPTS_DIR = resolve(PROJECT_ROOT, "src/prompts/agents");
+var RESOURCES_DIR = resolve(PROJECT_ROOT, "src/resources");
+var FILE_TAG_REGEX = /\[FILE:(\/[^\]]+)\]/gi;
+var MODEL_SONNET = "claude-sonnet-5";
+var MODEL_OPUS = "claude-opus-4-8";
+var MODEL_FABLE = "claude-fable-5";
+var FALLBACK_AGENT = resolveAgentEnv("FALLBACK_AGENT", "maestro", "DEFAULT_AGENT");
+var SESSION_AGENT = resolveAgentEnv("SESSION_AGENT", FALLBACK_AGENT);
+var GATEWAY_AGENT = resolveAgentEnv("GATEWAY_AGENT", FALLBACK_AGENT);
+var FALLBACK_MODEL = envText("FALLBACK_MODEL") ?? envText("DEFAULT_MODEL");
+function resolveModelEnv(envKey, agentConst) {
+  return envText(envKey) ?? (agentConst === FALLBACK_AGENT ? FALLBACK_MODEL : undefined);
+}
+var SESSION_MODEL = resolveModelEnv("SESSION_MODEL", SESSION_AGENT);
+var GATEWAY_MODEL = resolveModelEnv("GATEWAY_MODEL", GATEWAY_AGENT);
+var FFMPEG_BIN = envText("FFMPEG_BIN");
+var FFPROBE_BIN = envText("FFPROBE_BIN");
+var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
+var FASTER_WHISPER_WRAPPER = envText("FASTER_WHISPER_WRAPPER") ?? resolve(PROJECT_ROOT, "scripts/faster-whisper-wrapper.py");
+var WHISPER_MODEL = envText("WHISPER_MODEL_FILE") ?? "turbo";
+var TESSERACT_BIN = envText("TESSERACT_BIN") ?? "tesseract";
+var PDFTOTEXT_BIN = envText("PDFTOTEXT_BIN") ?? "pdftotext";
+var _envMaxTellDepth = Number.parseInt(process.env.MAX_TELL_DEPTH ?? "", 10);
+var MAX_TELL_DEPTH = Number.isInteger(_envMaxTellDepth) && _envMaxTellDepth > 0 ? _envMaxTellDepth : 20;
+function codexAuthFilePath() {
+  return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(homedir(), ".codex", "auth.json");
+}
+
+// ../../packages/core/src/agents/rollout/shared.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var trustedWorkspaceRoots = [WORKSPACE_DIR, DM_WORKSPACE_DIR, TOPIC_WORKSPACE_DIR].map((root) => resolve2(root));
+var FIXTURES_DIR = join2(__dirname2, "..", "fixtures");
+function clone(obj) {
+  return structuredClone(obj);
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertUuidLike(label, value) {
+  if (!UUID_RE.test(value)) {
+    throw new Error(`rollout: ${label} is not a UUID-shaped string: ${value}`);
+  }
+}
+function assertCwdInWorkspace(cwd) {
+  const abs = resolve2(cwd);
+  const ok = trustedWorkspaceRoots.some((root) => abs === root || abs.startsWith(`${root}/`));
+  if (!ok) {
+    throw new Error(`rollout: cwd outside trusted workspace roots: ${cwd} (resolved=${abs})`);
+  }
+}
+function ensureCwdExists(cwd) {
+  assertCwdInWorkspace(cwd);
+  try {
+    mkdirSync2(cwd, { recursive: true });
+  } catch (err) {
+    logger.warn({ err, cwd }, "rollout: ensureCwdExists failed \u2014 caller should pre-create cwd");
+  }
+}
+function truncate(text, n) {
+  const cps = Array.from(text);
+  return cps.length > n ? `${cps.slice(0, n).join("")}\u2026` : text;
+}
+function extractChatPairs(entries, opts = { includeToolAnnotations: true }) {
+  const pairs = [];
+  let pendingUser = null;
+  let pendingAssistantParts = [];
+  let toolBuffer = [];
+  const flushAssistant = () => {
+    if (pendingUser === null)
+      return;
+    const tools = opts.includeToolAnnotations && toolBuffer.length > 0 ? `
+
+${toolBuffer.join(`
+`)}` : "";
+    const assistantText = pendingAssistantParts.join("").trim() + tools;
+    if (assistantText.trim()) {
+      pairs.push({ userText: pendingUser, assistantText });
+    }
+    pendingUser = null;
+    pendingAssistantParts = [];
+    toolBuffer = [];
+  };
+  for (const entry of entries) {
+    const ev = entry.event;
+    switch (ev.type) {
+      case "user_message": {
+        flushAssistant();
+        pendingUser = ev.content;
+        break;
+      }
+      case "session":
+        if (pendingAssistantParts.length > 0 || toolBuffer.length > 0) {
+          flushAssistant();
+        }
+        break;
+      case "text": {
+        if (pendingUser === null) {
+          pendingUser = "(continued)";
+        }
+        pendingAssistantParts.push(ev.content);
+        break;
+      }
+      case "result": {
+        if (pendingUser === null) {
+          pendingUser = "(continued)";
+        }
+        pendingAssistantParts = [ev.content];
+        flushAssistant();
+        break;
+      }
+      case "text_delta":
+        break;
+      case "tool_use": {
+        const u = ev;
+        toolBuffer.push(`<!-- Tool: ${u.name} ${truncate(JSON.stringify(u.input), 200)} -->`);
+        break;
+      }
+      case "tool_result": {
+        const u = ev;
+        toolBuffer.push(`<!-- Tool result: ${truncate(u.content, 200)} -->`);
+        break;
+      }
+      case "error": {
+        const u = ev;
+        toolBuffer.push(`[Error: ${truncate(u.content, 200)}]`);
+        break;
+      }
+      case "tool_progress":
+      case "tool_use_summary":
+      case "file":
+      case "status":
+        break;
+    }
+  }
+  flushAssistant();
+  return pairs;
+}
+
+// ../../packages/core/src/platform/jsonl.ts
+import {
+  appendFileSync,
+  closeSync,
+  fsyncSync,
+  mkdirSync as mkdirSync3,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { dirname as dirname3 } from "path";
+function parseJsonlText(raw) {
+  return raw.trim().split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+}
+var LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function writeJsonlFile(filePath, entries) {
+  const dir = dirname3(filePath);
+  mkdirSync3(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(`
+`)}
+`;
+  let fd = null;
+  try {
+    fd = openSync(tmpPath, "w");
+    writeFileSync2(fd, payload);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    renameSync(tmpPath, filePath);
+    fsyncDirectoryBestEffort(dir);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+    try {
+      unlinkSync(tmpPath);
+    } catch {}
+    throw err;
+  }
+}
+function fsyncDirectoryBestEffort(dir) {
+  let fd = null;
+  try {
+    fd = openSync(dir, "r");
+    fsyncSync(fd);
+  } catch {} finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+
+// ../../packages/core/src/agents/rollout/claude.ts
+var _attachmentsCache = null;
+function loadClaudeAttachments() {
+  if (_attachmentsCache)
+    return _attachmentsCache;
+  const raw = readFileSync3(join3(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}`);
+  }
+  _attachmentsCache = {
+    deferredToolsDelta: lines[0],
+    skillListing: lines[1]
+  };
+  return _attachmentsCache;
+}
+var CLAUDE_SDK_VERSION = "2.1.126";
+var CLAUDE_DEFAULT_MODEL = "claude-sonnet-5";
+var CLAUDE_DEFAULT_GIT_BRANCH = "HEAD";
+function encodeClaudeCwd(cwd) {
+  const realCwd = cwd.startsWith("/tmp/") ? cwd.replace(/^\/tmp\//, "/private/tmp/") : cwd;
+  return `-${realCwd.replaceAll(/[^a-zA-Z0-9]/g, "-").replace(/^-/, "")}`;
+}
+function writeClaudeRollout(opts) {
+  const sessionId = opts.sessionId ?? randomUUID();
+  assertUuidLike("sessionId", sessionId);
+  ensureCwdExists(opts.cwd);
+  const pairs = opts.pairs ?? extractChatPairs(opts.entries ?? []);
+  const cwdReal = opts.cwd.startsWith("/tmp/") ? opts.cwd.replace(/^\/tmp\//, "/private/tmp/") : opts.cwd;
+  const lines = [];
+  const ts = () => new Date().toISOString();
+  let lastUuid = null;
+  lines.push({ type: "queue-operation", operation: "enqueue", timestamp: ts(), sessionId });
+  lines.push({ type: "queue-operation", operation: "dequeue", timestamp: ts(), sessionId });
+  const attachments = loadClaudeAttachments();
+  for (const pair of pairs) {
+    const userUuid = randomUUID();
+    lines.push({
+      parentUuid: lastUuid,
+      isSidechain: false,
+      promptId: randomUUID(),
+      type: "user",
+      message: { role: "user", content: [{ type: "text", text: pair.userText }] },
+      uuid: userUuid,
+      timestamp: ts(),
+      permissionMode: "bypassPermissions",
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH
+    });
+    const att1Uuid = randomUUID();
+    const att1 = clone(attachments.deferredToolsDelta);
+    att1.parentUuid = userUuid;
+    att1.uuid = att1Uuid;
+    att1.timestamp = ts();
+    att1.sessionId = sessionId;
+    att1.cwd = cwdReal;
+    lines.push(att1);
+    const att2Uuid = randomUUID();
+    const att2 = clone(attachments.skillListing);
+    att2.parentUuid = att1Uuid;
+    att2.uuid = att2Uuid;
+    att2.timestamp = ts();
+    att2.sessionId = sessionId;
+    att2.cwd = cwdReal;
+    lines.push(att2);
+    const assistantUuid = randomUUID();
+    lines.push({
+      parentUuid: att2Uuid,
+      isSidechain: false,
+      message: {
+        model: opts.model ?? CLAUDE_DEFAULT_MODEL,
+        id: `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`,
+        type: "message",
+        role: "assistant",
+        content: [{ type: "text", text: pair.assistantText }],
+        stop_reason: "end_turn",
+        stop_sequence: null,
+        stop_details: null,
+        usage: {
+          input_tokens: 0,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          output_tokens: 0,
+          server_tool_use: { web_search_requests: 0, web_fetch_requests: 0 },
+          service_tier: "standard",
+          cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
+          inference_geo: "",
+          iterations: [],
+          speed: "standard"
+        },
+        diagnostics: null
+      },
+      requestId: `req_${randomUUID().replace(/-/g, "").slice(0, 22)}`,
+      type: "assistant",
+      uuid: assistantUuid,
+      timestamp: ts(),
+      userType: "external",
+      entrypoint: "sdk-ts",
+      cwd: cwdReal,
+      sessionId,
+      version: CLAUDE_SDK_VERSION,
+      gitBranch: CLAUDE_DEFAULT_GIT_BRANCH
+    });
+    lastUuid = assistantUuid;
+  }
+  const projectsDir = join3(homedir2(), ".claude", "projects", encodeClaudeCwd(opts.cwd));
+  const path = join3(projectsDir, `${sessionId}.jsonl`);
+  writeJsonlFile(path, lines);
+  logger.info({ sessionId, path, pairs: pairs.length }, "writeClaudeRollout: synthetic rollout placed");
+  return { sessionId, rolloutPath: path };
+}
+
+// ../../packages/core/src/agents/claude-registry.ts
+var ALIAS_MAP = {
+  sonnet: MODEL_SONNET,
+  opus: MODEL_OPUS,
+  fable: MODEL_FABLE
+};
+var VALID_ALIASES = new Set(Object.keys(ALIAS_MAP));
+var VALID_EFFORTS = new Set(CLAUDE_EFFORT_VALUES);
+var claudeRegistry = {
+  kind: "claude",
+  defaultModel: "sonnet",
+  defaultEffort: "high",
+  expandModelAlias(s) {
+    return ALIAS_MAP[s] ?? s;
+  },
+  validateModel(s) {
+    return VALID_ALIASES.has(s);
+  },
+  validEfforts: CLAUDE_EFFORT_VALUES,
+  validateEffort(s) {
+    return VALID_EFFORTS.has(s);
+  },
+  footerLabel(model, effort) {
+    return effort ? `${model} \xB7 ${effort}` : model;
+  },
+  writeRollout(opts) {
+    const { sessionId, rolloutPath } = writeClaudeRollout({
+      cwd: opts.cwd,
+      entries: opts.entries,
+      model: claudeRegistry.expandModelAlias(opts.model ?? claudeRegistry.defaultModel),
+      ...opts.reuseSessionId ? { sessionId: opts.reuseSessionId } : {}
+    });
+    return { sessionId, rolloutPath };
+  },
+  async forkSession({ parentSessionId, cwd, title }) {
+    const { forkSession } = await import("@anthropic-ai/claude-agent-sdk");
+    const result = await forkSession(parentSessionId, {
+      ...title ? { title } : {}
+    });
+    const projectsRoot = join4(homedir3(), ".claude", "projects");
+    const destDir = join4(projectsRoot, encodeClaudeCwd(cwd));
+    const destPath = join4(destDir, `${result.sessionId}.jsonl`);
+    if (!existsSync3(destPath)) {
+      const sourcePath = readdirSync(projectsRoot).map((d) => join4(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync3(p));
+      if (!sourcePath) {
+        throw new Error(`claude forkSession: fork rollout ${result.sessionId}.jsonl not found under ${projectsRoot}`);
+      }
+      mkdirSync4(destDir, { recursive: true });
+      renameSync2(sourcePath, destPath);
+    }
+    return {
+      forkId: result.sessionId,
+      rolloutPath: destPath
+    };
+  },
+  async cleanupRollouts({ cwd, sessionIds }) {
+    const projectsDir = join4(homedir3(), ".claude", "projects", encodeClaudeCwd(cwd));
+    const failures = [];
+    for (const sid of sessionIds) {
+      const path = join4(projectsDir, `${sid}.jsonl`);
+      try {
+        unlinkSync2(path);
+      } catch (e) {
+        if (e?.code !== "ENOENT") {
+          logger.warn({ err: e, path }, "claude cleanupRollouts: unlink failed");
+          failures.push(e);
+        }
+      }
+    }
+    if (failures.length > 0) {
+      throw new AggregateError(failures, "claude cleanupRollouts failed");
+    }
+  }
+};
+
+// ../../packages/core/src/agents/deep-map.ts
+function deepMapStrings(value, fn) {
+  if (typeof value === "string")
+    return fn(value);
+  if (Array.isArray(value))
+    return value.map((v) => deepMapStrings(v, fn));
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = deepMapStrings(v, fn);
+    }
+    return out;
+  }
+  return value;
+}
+
+// ../../packages/core/src/agents/execution-host.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// ../../packages/core/src/security/sensitive-path.ts
+import { realpathSync } from "fs";
+import { resolve as resolve3 } from "path";
+var SENSITIVE_PATH_PATTERNS = [
+  /\/\.env(\.|$)/i,
+  /\/\.ssh\//i,
+  /\/\.aws\//i,
+  /\/\.gnupg\//i,
+  /\/\.netrc$/i,
+  /\/\.npmrc$/i,
+  /\/(id_rsa|id_ed25519|id_ecdsa|id_dsa)(\.pub)?$/i,
+  /\.(pem|key|p12|pfx|cer|crt)$/i,
+  /\/Library\/Keychains\//i,
+  /\/vault\.db(-wal|-shm|-journal)?$/i,
+  /\/vault-master-key$/i,
+  /\/runtime-mcp-secret$/i,
+  /\/sessions\.db(-wal|-shm|-journal)?$/i
+];
+function isSensitivePath(filePath) {
+  const normalized = resolve3(filePath);
+  if (SENSITIVE_PATH_PATTERNS.some((p) => p.test(normalized)))
+    return true;
+  try {
+    const real = realpathSync(normalized);
+    if (real !== normalized)
+      return SENSITIVE_PATH_PATTERNS.some((p) => p.test(real));
+  } catch {}
+  return false;
+}
+
+// ../../packages/core/src/storage/vault.ts
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync5 } from "fs";
+import { join as join5 } 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 = join5(dataDir, "vault.db");
+  mkdirSync5(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 vaultList(userId) {
+  return activeVaultDatabase().prepare("SELECT key, description FROM vault WHERE user_id = ? ORDER BY key").all(userId);
+}
+function valueReferencesVaultKey(userId, value) {
+  const keys = new Set(vaultList(userId).map((entry) => entry.key));
+  const visit = (candidate) => {
+    if (typeof candidate === "string") {
+      for (const match of candidate.matchAll(/\{\{([^}]+)\}\}/g)) {
+        if (keys.has(normalizeVaultKey(match[1] ?? "")))
+          return true;
+      }
+      return false;
+    }
+    if (Array.isArray(candidate))
+      return candidate.some(visit);
+    if (candidate && typeof candidate === "object") {
+      return Object.values(candidate).some(visit);
+    }
+    return false;
+  };
+  return visit(value);
+}
+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/vault-tool-policy.ts
+var SENSITIVE_RUNTIME_NAMES = [
+  "vault.db",
+  "vault-master-key",
+  "runtime-mcp-secret",
+  "sessions.db"
+];
+var VAULT_BROKER_REDIRECT_ERROR = "Vault placeholders must be executed through mcp__vault__vault_run (shell/CLI) or mcp__vault__vault_http_request (HTTP) so secret values cannot enter the model transcript.";
+function isVaultBrokerTool(toolName) {
+  return toolName.includes("vault_run") || toolName.includes("vault_http_request");
+}
+function referencesRuntimeSecretStorage(value) {
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (SENSITIVE_RUNTIME_NAMES.some((name) => lower.includes(name)))
+      return true;
+    return value.startsWith("/") && isSensitivePath(value);
+  }
+  if (Array.isArray(value))
+    return value.some(referencesRuntimeSecretStorage);
+  if (value && typeof value === "object") {
+    return Object.values(value).some(referencesRuntimeSecretStorage);
+  }
+  return false;
+}
+function shouldRedirectVaultTool(userId, toolName, input) {
+  return !isVaultBrokerTool(toolName) && valueReferencesVaultKey(userId, input);
+}
+
+// ../../packages/core/src/platform/mcp-config.ts
+import { createHmac as createHmac2 } from "crypto";
+
+// ../../packages/core/src/mcp/runtime-spec.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var RUNTIME_MCP_KEY = "runtime";
+var RUNTIME_MCP_BASE_PATH = "/mcp/runtime";
+var TOKEN_TTL_MS = 4 * 60 * 60 * 1000;
+var CLAUDE_MCP_TOOL_TIMEOUT_MS = 600000;
+var runtimePort = NEGOTIUM_PORT;
+function encodeTokenPart(value) {
+  return Buffer.from(JSON.stringify(value), "utf-8").toString("base64url");
+}
+function signTokenPayload(payloadPart) {
+  return createHmac("sha256", RUNTIME_MCP_SECRET).update(payloadPart).digest("base64url");
+}
+function issueRuntimeMcpToken(ctx) {
+  const payloadPart = encodeTokenPart({
+    v: 1,
+    exp: Date.now() + TOKEN_TTL_MS,
+    ctx
+  });
+  return `${payloadPart}.${signTokenPayload(payloadPart)}`;
+}
+function buildRuntimeMcpSpec(agent, ctx) {
+  const token = issueRuntimeMcpToken(ctx);
+  const base = `http://127.0.0.1:${runtimePort}${RUNTIME_MCP_BASE_PATH}`;
+  const query = `token=${encodeURIComponent(token)}`;
+  if (agent === "codex")
+    return { url: `${base}/mcp?${query}` };
+  return {
+    type: "sse",
+    url: `${base}/sse?${query}`,
+    timeout: CLAUDE_MCP_TOOL_TIMEOUT_MS
+  };
+}
+
+// ../../packages/core/src/mcp/session-comm/bridge-ipc-config.ts
+var registrations = [];
+function peerSessionBridgeIpcEnv() {
+  const active = registrations.at(-1)?.config;
+  if (!active)
+    return;
+  return {
+    NEGOTIUM_PEER_SESSION_BRIDGE_URL: active.url,
+    NEGOTIUM_PEER_SESSION_BRIDGE_TOKEN: active.token
+  };
+}
+
+// ../../packages/core/src/platform/mcp-config.ts
+function buildStdioMcpServer(agent, serverFile, serverArgs, env) {
+  if (agent === "codex") {
+    return {
+      command: "node",
+      args: [TSX_BIN, serverFile, ...serverArgs],
+      env: { TSX_TSCONFIG_PATH: TSCONFIG_PATH, ...env }
+    };
+  }
+  return {
+    command: "bun",
+    args: ["run", serverFile, ...serverArgs],
+    ...env ? { env } : {}
+  };
+}
+var _playwrightUnavailableNotifier;
+var _playwrightUnavailableLastNotifiedAt = new Map;
+var _PLAYWRIGHT_UNAVAILABLE_COOLDOWN_MS = 5 * 60000;
+var _playwrightUnavailableThisTurn = new Set;
+function _playwrightUnavailableKey(userId, topic) {
+  return `${userId}:${topic ?? ""}`;
+}
+function _markPlaywrightUnavailable(ctx) {
+  _playwrightUnavailableThisTurn.add(_playwrightUnavailableKey(ctx.userId, ctx.topic));
+  if (!_playwrightUnavailableNotifier)
+    return;
+  const key = _playwrightUnavailableKey(ctx.userId, ctx.topic);
+  const now = Date.now();
+  const last = _playwrightUnavailableLastNotifiedAt.get(key) ?? 0;
+  if (now - last < _PLAYWRIGHT_UNAVAILABLE_COOLDOWN_MS)
+    return;
+  _playwrightUnavailableLastNotifiedAt.set(key, now);
+  try {
+    _playwrightUnavailableNotifier(ctx);
+  } catch (err) {
+    logger.warn({ err }, "playwright unavailable notifier threw");
+  }
+}
+var CODEX_BROWSER_CAPABILITY_ENV = "NEGOTIUM_BROWSER_CAPABILITY";
+function browserOwnerCapability(capability, owner) {
+  return createHmac2("sha256", capability).update(owner).digest("hex");
+}
+function browserOwnerForContext(ctx) {
+  if (ctx.topicId)
+    return `topic:${ctx.topicId}`;
+  if (ctx.userId && ctx.session)
+    return `user:${ctx.userId}:${ctx.session}`;
+  return;
+}
+function playwrightTransport(port, owner, capability, agent) {
+  const ownerCapability = browserOwnerCapability(capability, owner);
+  if (agent === "codex") {
+    return {
+      url: `http://127.0.0.1:${port}/mcp`,
+      http_headers: { "X-Browser-Owner": owner },
+      env_http_headers: { "X-Browser-Capability": CODEX_BROWSER_CAPABILITY_ENV }
+    };
+  }
+  if (agent === "maestro") {
+    const query = new URLSearchParams({ owner, capability: ownerCapability });
+    return {
+      type: "sse",
+      url: `http://127.0.0.1:${port}/sse?${query}`
+    };
+  }
+  return {
+    type: "sse",
+    url: `http://127.0.0.1:${port}/sse`,
+    headers: { "X-Browser-Owner": owner, "X-Browser-Capability": ownerCapability }
+  };
+}
+function longLivedHttpMcp(agent, port) {
+  return agent === "codex" ? { url: `http://127.0.0.1:${port}/mcp` } : { type: "sse", url: `http://127.0.0.1:${port}/sse` };
+}
+var MCP_CATALOG = {
+  playwright: {
+    scopes: ["dm", "forum", "fork", "cron"],
+    build({ userId, session, topicId, playwrightPort, playwrightCapability, agent }) {
+      if (playwrightPort && playwrightCapability) {
+        const owner = browserOwnerForContext({ userId, session, topicId });
+        if (!owner)
+          return null;
+        return playwrightTransport(playwrightPort, owner, playwrightCapability, agent);
+      }
+      _markPlaywrightUnavailable({
+        userId,
+        topic: session,
+        agent
+      });
+      return null;
+    }
+  },
+  [RUNTIME_MCP_KEY]: {
+    scopes: ["forum", "manager", "fork", "cron"],
+    forumRequired: true,
+    build({
+      userId,
+      session,
+      topicId,
+      queryId,
+      agent,
+      cwd,
+      model,
+      currentUserPrompt,
+      autoContinue,
+      visualTools,
+      fileDeliveryTools,
+      peerBridge
+    }) {
+      if (!topicId || !agent)
+        return null;
+      return buildRuntimeMcpSpec(agent, {
+        userId,
+        topicId,
+        topicTitle: session,
+        queryId,
+        cwd: cwd ?? resolveTopicWorkspaceDir(topicId),
+        agent,
+        model,
+        currentUserPrompt,
+        autoContinue,
+        visualTools,
+        fileDeliveryTools,
+        peerBridge
+      });
+    }
+  },
+  paddleocr: {
+    scopes: ["dm", "forum", "fork", "cron"],
+    build({ agent }) {
+      return buildStdioMcpServer(agent, PADDLEOCR_SERVER, []);
+    }
+  },
+  "token-stats": {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, agent }) {
+      return buildStdioMcpServer(agent, TOKEN_STATS_SERVER, [`--user-id=${userId}`]);
+    }
+  },
+  task: {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, session, topicId, queryId, agent, peerBridge }) {
+      if (peerBridge) {
+        if (!topicId || !queryId)
+          return null;
+        const env = canonicalMcpBridgeEnv({
+          surface: "task",
+          userId,
+          topicId,
+          queryId,
+          peerBridge
+        });
+        return env ? buildStdioMcpServer(agent, CANONICAL_MCP_PROXY_SERVER, ["--surface=task"], env) : null;
+      }
+      const args = [`--user-id=${userId}`, `--topic=${session}`];
+      if (topicId)
+        args.push(`--topic-id=${topicId}`);
+      return buildStdioMcpServer(agent, TASK_SERVER, args);
+    }
+  },
+  "session-comm": {
+    scopes: ["forum", "fork", "manager"],
+    forumRequired: true,
+    build({ userId, session, topicId, agent, depth = 0, silent, peerBridge }) {
+      const effectiveAgent = agent ?? FALLBACK_AGENT;
+      const args = [
+        `--user-id=${userId}`,
+        `--topic=${session}`,
+        ...topicId ? [`--topic-id=${topicId}`] : [],
+        `--depth=${depth}`,
+        `--agent=${effectiveAgent}`,
+        ...silent ? ["--reply-only=true"] : [],
+        ...peerBridge ? [`--peer-host-query-id=${peerBridge.hostQueryId}`] : []
+      ];
+      return buildStdioMcpServer(effectiveAgent, SESSION_COMM_SERVER, args, peerBridge ? peerSessionBridgeIpcEnv() : undefined);
+    }
+  },
+  wiki: {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, session, topicId, queryId, wikiTopicId, agent, peerBridge }) {
+      if (peerBridge) {
+        if (!topicId || !queryId)
+          return null;
+        const env = canonicalMcpBridgeEnv({
+          surface: "wiki",
+          userId,
+          topicId,
+          queryId,
+          peerBridge
+        });
+        return env ? buildStdioMcpServer(agent, CANONICAL_MCP_PROXY_SERVER, ["--surface=wiki"], env) : null;
+      }
+      const args = [`--user-id=${userId}`];
+      const resolvedWikiTopicId = wikiTopicId ?? topicId ?? (session !== "dm" ? session : undefined);
+      if (resolvedWikiTopicId)
+        args.push(`--topic-id=${resolvedWikiTopicId}`);
+      args.push("--surface=wiki");
+      return buildStdioMcpServer(agent, WIKI_SERVER, args);
+    }
+  },
+  skills: {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, topicId, agent }) {
+      const args = [`--user-id=${userId}`, "--surface=skills"];
+      if (topicId)
+        args.push(`--topic-id=${topicId}`);
+      return buildStdioMcpServer(agent, WIKI_SERVER, args);
+    }
+  },
+  "system-health": {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ agent }) {
+      return buildStdioMcpServer(agent, SYSTEM_HEALTH_SERVER, []);
+    }
+  },
+  "background-bash": {
+    scopes: ["forum"],
+    build({ agent, bgBashPort }) {
+      if (bgBashPort === undefined)
+        return null;
+      return longLivedHttpMcp(agent, bgBashPort);
+    }
+  },
+  "agent-health": {
+    scopes: ["forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, agent }) {
+      const args = [`--user-id=${userId}`];
+      return buildStdioMcpServer(agent, AGENT_HEALTH_SERVER, args);
+    }
+  },
+  vault: {
+    scopes: ["dm", "forum", "manager", "cron"],
+    forumRequired: true,
+    build({ userId, agent }) {
+      const args = [`--user-id=${userId}`];
+      if (agent === "codex")
+        args.push("--http-only=true");
+      return buildStdioMcpServer(agent, VAULT_SERVER, args);
+    }
+  }
+};
+function namesInScope(scope) {
+  return Object.entries(MCP_CATALOG).filter(([, e]) => e.scopes.includes(scope)).map(([name]) => name);
+}
+var allForumMcpServerNames = [];
+var requiredForumMcpServers = [];
+var REQUIRED_FORUM_MCP_SERVERS = requiredForumMcpServers;
+var optionalForumMcpServers = [];
+function refreshForumCatalogViews() {
+  const all = namesInScope("forum");
+  const required = Object.entries(MCP_CATALOG).filter(([, entry]) => entry.scopes.includes("forum") && entry.forumRequired).map(([name]) => name);
+  allForumMcpServerNames.splice(0, allForumMcpServerNames.length, ...all);
+  requiredForumMcpServers.splice(0, requiredForumMcpServers.length, ...required);
+  optionalForumMcpServers.splice(0, optionalForumMcpServers.length, ...all.filter((name) => !required.includes(name)));
+}
+refreshForumCatalogViews();
+var nodeMcpEntries = [];
+function buildNodeMcpSpecs(agent, filter) {
+  const out = {};
+  for (const entry of nodeMcpEntries) {
+    if (!filter(entry.key))
+      continue;
+    out[entry.key] = entry.kind === "http" ? longLivedHttpMcp(agent, entry.port) : {
+      command: entry.command,
+      args: entry.args ?? [],
+      ...entry.env ? { env: entry.env } : {}
+    };
+  }
+  return out;
+}
+function buildScope(scope, ctx, filter = () => true) {
+  const out = {};
+  for (const [name, entry] of Object.entries(MCP_CATALOG)) {
+    if (!entry.scopes.includes(scope))
+      continue;
+    if (!filter(name))
+      continue;
+    const spec = entry.build(ctx);
+    if (spec === null)
+      continue;
+    out[name] = spec;
+  }
+  if (scope !== "cron") {
+    Object.assign(out, buildNodeMcpSpecs(ctx.agent, filter));
+  }
+  return out;
+}
+function getDmMcpServers(opts) {
+  return buildScope("dm", {
+    userId: opts.userId,
+    session: "dm",
+    agent: opts.agent,
+    playwrightPort: opts.playwrightPort,
+    playwrightCapability: opts.playwrightCapability
+  });
+}
+function getManagerMcpServers(opts) {
+  if (!opts.topicId) {
+    throw new Error("getManagerMcpServers: private General topicId is required");
+  }
+  const topicId = opts.topicId;
+  return buildScope("manager", {
+    userId: opts.userId,
+    session: opts.session ?? "General",
+    topicId,
+    queryId: opts.queryId,
+    wikiTopicId: opts.wikiTopicId ?? topicId,
+    agent: opts.agent,
+    cwd: opts.cwd,
+    model: opts.model,
+    currentUserPrompt: opts.currentUserPrompt,
+    playwrightPort: opts.playwrightPort,
+    playwrightCapability: opts.playwrightCapability,
+    autoContinue: opts.autoContinue,
+    visualTools: opts.visualTools,
+    fileDeliveryTools: opts.fileDeliveryTools
+  });
+}
+function getForumMcpServers(opts) {
+  const {
+    userId,
+    session,
+    topicId,
+    queryId,
+    wikiTopicId,
+    agent,
+    cwd,
+    model,
+    currentUserPrompt,
+    playwrightPort,
+    playwrightCapability,
+    depth = 0,
+    enabled = null,
+    extra = {},
+    silent = false,
+    bgBashPort,
+    autoContinue,
+    visualTools,
+    fileDeliveryTools,
+    peerBridge
+  } = 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/agents/execution-host.ts
+var defaultHost = {
+  getMcpServersForQuery,
+  redactVaultSecrets,
+  referencesRuntimeSecretStorage,
+  shouldRedirectVaultTool,
+  claudeCodeExecutablePath: () => CLAUDE_EXECUTABLE,
+  codexAuthFilePath
+};
+var hostRegistrations = [];
+var scopedHost = new AsyncLocalStorage;
+function activeHost() {
+  const scoped = scopedHost.getStore();
+  if (scoped)
+    return scoped;
+  const host = { ...defaultHost };
+  for (const registration of hostRegistrations)
+    Object.assign(host, registration.overrides);
+  return host;
+}
+function resolveAgentExecutionHost(overrides = {}) {
+  return { ...activeHost(), ...overrides };
+}
+function withAgentExecutionHost(host, operation) {
+  return scopedHost.run(host, operation);
+}
+function configureAgentExecutionHost(overrides) {
+  const registration = { id: Symbol("agent-execution-host"), overrides };
+  hostRegistrations.push(registration);
+  let disposed = false;
+  return () => {
+    if (disposed)
+      return;
+    disposed = true;
+    const index = hostRegistrations.findIndex((entry) => entry.id === registration.id);
+    if (index >= 0)
+      hostRegistrations.splice(index, 1);
+  };
+}
+function hostedMcpServers(opts) {
+  return activeHost().getMcpServersForQuery(opts);
+}
+function redactHostedSecrets(userId, value) {
+  return activeHost().redactVaultSecrets(userId, value);
+}
+function referencesHostedSecretStorage(value) {
+  return activeHost().referencesRuntimeSecretStorage(value);
+}
+function shouldRedirectHostedVaultTool(userId, toolName, input) {
+  return activeHost().shouldRedirectVaultTool(userId, toolName, input);
+}
+function transformHostedQueryOptions(opts) {
+  return activeHost().transformQueryOptions?.(opts) ?? opts;
+}
+function hostedClaudeCodeExecutablePath() {
+  return activeHost().claudeCodeExecutablePath();
+}
+function hostedCodexAuthFilePath() {
+  return activeHost().codexAuthFilePath();
+}
+
+// ../../packages/core/src/media/file-events.ts
+function* extractFileEvents(text, source) {
+  const tagRegex = new RegExp(FILE_TAG_REGEX.source, "gi");
+  let match = tagRegex.exec(text);
+  while (match !== null) {
+    yield { type: "file", path: match[1], source, origin: "tag" };
+    match = tagRegex.exec(text);
+  }
+}
+
+// ../../packages/core/src/platform/error.ts
+function errMsg(e, fallback) {
+  if (e instanceof Error)
+    return e.message;
+  return fallback ?? String(e);
+}
+
+// ../../packages/core/src/agents/claude-provider.ts
+var CLAUDE_DEFAULT_DISALLOWED_TOOLS = [
+  "AskUserQuestion",
+  "Workflow",
+  "TodoWrite",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskList",
+  "TaskGet",
+  "Task",
+  "Agent",
+  "TaskOutput",
+  "TaskStop"
+];
+function buildClaudeDisallowedTools(extra = undefined) {
+  return [...new Set([...CLAUDE_DEFAULT_DISALLOWED_TOOLS, ...extra ?? []])];
+}
+function toClaudeEffort(e) {
+  if (!e || !claudeRegistry.validateEffort(e))
+    return;
+  return e;
+}
+var CLAUDE_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+var CLAUDE_IMAGE_MIME_TYPES = new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+function isClaudeImageAttachment(attachment) {
+  return attachment.type === "image" && CLAUDE_IMAGE_MIME_TYPES.has(attachment.mimeType);
+}
+async function* singleUserMessage(message) {
+  yield message;
+}
+function buildClaudePrompt(opts) {
+  const attachments = opts.attachments ?? [];
+  if (attachments.length === 0)
+    return opts.prompt;
+  const imageBlocks = [];
+  for (const attachment of attachments) {
+    if (!isClaudeImageAttachment(attachment))
+      continue;
+    if (attachment.sizeBytes > CLAUDE_IMAGE_MAX_BYTES) {
+      logger.info({
+        path: attachment.path,
+        mimeType: attachment.mimeType,
+        sizeBytes: attachment.sizeBytes,
+        maxBytes: CLAUDE_IMAGE_MAX_BYTES
+      }, "claudeProvider: skipping oversized image attachment content block");
+      continue;
+    }
+    try {
+      imageBlocks.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: attachment.mimeType,
+          data: readFileSync4(attachment.path).toString("base64")
+        }
+      });
+    } catch (err) {
+      logger.warn({
+        path: attachment.path,
+        mimeType: attachment.mimeType,
+        err
+      }, "claudeProvider: failed to read image attachment for content block");
+    }
+  }
+  if (imageBlocks.length === 0)
+    return opts.prompt;
+  const content = [{ type: "text", text: opts.prompt }, ...imageBlocks];
+  return singleUserMessage({
+    type: "user",
+    message: {
+      role: "user",
+      content
+    },
+    parent_tool_use_id: null
+  });
+}
+var CLAUDE_ABORT_SIGKILL_DELAY_MS = 2500;
+function signalProcessTree(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (groupErr) {
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch (pidErr) {
+      logger.debug({ groupErr, pidErr, pid, signal }, "Failed to signal Claude process tree");
+      return false;
+    }
+  }
+}
+function spawnClaudeCodeProcessWithTreeKill(options) {
+  const child = spawn(options.command, options.args, {
+    cwd: options.cwd,
+    detached: true,
+    env: options.env,
+    stdio: ["pipe", "pipe", "inherit"]
+  });
+  if (!child.stdin || !child.stdout) {
+    child.kill("SIGKILL");
+    throw new Error("Failed to spawn Claude Code process with piped stdin/stdout");
+  }
+  let exited = false;
+  let killTimer;
+  const clearKillTimer = () => {
+    if (killTimer)
+      clearTimeout(killTimer);
+    killTimer = undefined;
+  };
+  const kill = (signal) => {
+    if (!child.pid)
+      return child.kill(signal);
+    const ok = signalProcessTree(child.pid, signal);
+    if (signal !== "SIGKILL") {
+      clearKillTimer();
+      killTimer = setTimeout(() => {
+        if (!exited && child.pid) {
+          logger.warn({ pid: child.pid }, "Claude process tree still alive after SIGTERM; SIGKILL");
+          signalProcessTree(child.pid, "SIGKILL");
+        }
+      }, CLAUDE_ABORT_SIGKILL_DELAY_MS);
+      killTimer.unref?.();
+    }
+    return ok;
+  };
+  const onAbort = () => {
+    logger.warn({ pid: child.pid, command: options.command }, "Aborting Claude Code process tree");
+    kill("SIGTERM");
+  };
+  if (options.signal.aborted)
+    onAbort();
+  else
+    options.signal.addEventListener("abort", onAbort, { once: true });
+  child.once("exit", (code, signal) => {
+    exited = true;
+    clearKillTimer();
+    options.signal.removeEventListener("abort", onAbort);
+    logger.debug({ pid: child.pid, code, signal }, "Claude Code process exited");
+  });
+  child.once("error", (err) => {
+    exited = true;
+    clearKillTimer();
+    options.signal.removeEventListener("abort", onAbort);
+    logger.error({
+      pid: child.pid,
+      command: options.command,
+      err: err instanceof Error ? err.message : String(err)
+    }, "Claude Code process error event");
+  });
+  return {
+    stdin: child.stdin,
+    stdout: child.stdout,
+    get killed() {
+      return child.killed || exited;
+    },
+    get exitCode() {
+      return child.exitCode;
+    },
+    kill,
+    on(event, listener) {
+      child.on(event, listener);
+    },
+    once(event, listener) {
+      child.once(event, listener);
+    },
+    off(event, listener) {
+      child.off(event, listener);
+    }
+  };
+}
+function isAbortError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  if (e.name === "AbortError")
+    return true;
+  if (e.code === 20 || e.code === "ABORT_ERR")
+    return true;
+  return false;
+}
+async function* claudeProvider(opts) {
+  const claudeExecutable = hostedClaudeCodeExecutablePath();
+  if (claudeExecutable && !existsSync4(claudeExecutable)) {
+    yield {
+      type: "error",
+      content: `Claude CLI not found at ${claudeExecutable}. Install Claude Code or configure the executable path.`
+    };
+    return;
+  }
+  const cleanEnv = { ...process.env };
+  delete cleanEnv.NEGOTIUM_PEER_SESSION_BRIDGE_URL;
+  delete cleanEnv.NEGOTIUM_PEER_SESSION_BRIDGE_TOKEN;
+  delete cleanEnv.CLAUDECODE;
+  cleanEnv.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT ??= process.env.PADDLEOCR_TIMEOUT_MS ?? "300000";
+  cleanEnv.CLAUDE_CODE_DISABLE_WORKFLOWS = "1";
+  const queryOptions = {
+    ...claudeExecutable ? { pathToClaudeCodeExecutable: claudeExecutable } : {},
+    spawnClaudeCodeProcess: spawnClaudeCodeProcessWithTreeKill,
+    cwd: opts.cwd,
+    permissionMode: "bypassPermissions",
+    allowDangerouslySkipPermissions: true,
+    includePartialMessages: true,
+    env: cleanEnv,
+    mcpServers: hostedMcpServers(opts),
+    abortController: opts.abortController,
+    disallowedTools: buildClaudeDisallowedTools(opts.disallowedTools),
+    ...opts.model ? { model: opts.model } : {},
+    ...opts.maxBudgetUsd ? { maxBudgetUsd: opts.maxBudgetUsd } : {},
+    ...opts.agents ? {
+      agents: Object.fromEntries(Object.entries(opts.agents).map(([name, def]) => {
+        const { effort, ...rest } = def;
+        const narrowed = typeof effort === "string" ? toClaudeEffort(effort) : effort;
+        return [name, narrowed !== undefined ? { ...rest, effort: narrowed } : rest];
+      }))
+    } : {},
+    ...toClaudeEffort(opts.effort) ? { effort: toClaudeEffort(opts.effort) } : {},
+    hooks: {
+      PreToolUse: [
+        {
+          hooks: [
+            async (input) => {
+              const { tool_name, tool_input } = input;
+              if (referencesHostedSecretStorage(tool_input)) {
+                return {
+                  hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: "Runtime secret storage access is not permitted"
+                  }
+                };
+              }
+              if (tool_name === "Bash" && tool_input?.run_in_background === true) {
+                return {
+                  hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "deny",
+                    permissionDecisionReason: "run_in_background is not supported in headless mode \u2014 the bash process dies when the agent turn ends. Use mcp__background-bash__background_bash_run instead: it survives across turns and automatically injects the result into the session when done."
+                  }
+                };
+              }
+              const userId = opts.userId ?? "";
+              if (!shouldRedirectHostedVaultTool(userId, tool_name, tool_input)) {
+                return { continue: true };
+              }
+              return {
+                hookSpecificOutput: {
+                  hookEventName: "PreToolUse",
+                  permissionDecision: "deny",
+                  permissionDecisionReason: VAULT_BROKER_REDIRECT_ERROR
+                }
+              };
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          hooks: [
+            async (input) => {
+              const { tool_response } = input;
+              const userId = opts.userId ?? "";
+              const redacted = deepMapStrings(tool_response, (value) => redactHostedSecrets(userId, value));
+              if (JSON.stringify(redacted) === JSON.stringify(tool_response)) {
+                return { continue: true };
+              }
+              return {
+                hookSpecificOutput: {
+                  hookEventName: "PostToolUse",
+                  updatedToolOutput: redacted
+                }
+              };
+            }
+          ]
+        }
+      ]
+    },
+    settingSources: ["project"],
+    settings: {
+      disableWorkflows: true,
+      workflowKeywordTriggerEnabled: false
+    },
+    systemPrompt: opts.systemPrompt
+  };
+  if (opts.sessionId) {
+    queryOptions.resume = opts.sessionId;
+  }
+  const THINKING_BEAT_MS = 5000;
+  let thinkingStart = null;
+  let lastThinkingBeat = 0;
+  let lastContextTokens;
+  let lastContextModel;
+  const thinkingBeat = () => {
+    const now = Date.now();
+    if (thinkingStart === null) {
+      thinkingStart = now;
+      lastThinkingBeat = now;
+      return { type: "tool_progress", toolName: "thinking", elapsed: 0 };
+    }
+    if (now - lastThinkingBeat < THINKING_BEAT_MS)
+      return null;
+    lastThinkingBeat = now;
+    return { type: "tool_progress", toolName: "thinking", elapsed: (now - thinkingStart) / 1000 };
+  };
+  try {
+    const prompt = buildClaudePrompt(opts);
+    for await (const message of query({
+      prompt,
+      options: queryOptions
+    })) {
+      if (message.type === "system" && message.subtype === "thinking_tokens") {
+        const beat = thinkingBeat();
+        if (beat)
+          yield beat;
+        continue;
+      }
+      if (message.type === "stream_event") {
+        const streamMsg = message;
+        const evt = streamMsg.event;
+        if (!evt)
+          continue;
+        if (evt.type === "content_block_delta") {
+          const delta = evt;
+          if (delta.delta.type === "thinking_delta") {
+            const beat = thinkingBeat();
+            if (beat)
+              yield beat;
+          } else if (delta.delta.type === "text_delta" && delta.delta.text) {
+            thinkingStart = null;
+          } else {
+            thinkingStart = null;
+          }
+        }
+        continue;
+      }
+      thinkingStart = null;
+      if (message.type === "tool_progress") {
+        const m = message;
+        yield {
+          type: "tool_progress",
+          toolName: m.tool_name,
+          elapsed: m.elapsed_time_seconds
+        };
+        continue;
+      }
+      if (message.type === "tool_use_summary") {
+        const m = message;
+        yield { type: "tool_use_summary", summary: m.summary };
+        continue;
+      }
+      if (message.type === "system") {
+        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)");
+        }
+        continue;
+      }
+      if (message.type === "result") {
+        const m = message;
+        if (m.subtype === "success") {
+          const contextWindow = (lastContextModel ? m.modelUsage?.[lastContextModel]?.contextWindow : undefined) ?? Object.values(m.modelUsage ?? {})[0]?.contextWindow;
+          yield {
+            type: "result",
+            content: m.result,
+            stopReason: m.stop_reason ?? "end_turn",
+            usage: m.usage ? {
+              inputTokens: m.usage.input_tokens,
+              outputTokens: m.usage.output_tokens,
+              cacheCreationInputTokens: m.usage.cache_creation_input_tokens ?? undefined,
+              cacheReadInputTokens: m.usage.cache_read_input_tokens ?? undefined,
+              costUsd: m.total_cost_usd,
+              ...lastContextTokens !== undefined && contextWindow ? { contextTokens: lastContextTokens, contextWindow } : {}
+            } : undefined
+          };
+          yield* extractFileEvents(m.result, "result");
+          return;
+        }
+        const budgetExceeded = m.subtype === "error_max_budget_usd";
+        const errorMsg = budgetExceeded ? "The job reached its cost limit" : m.errors?.join("; ") || "Unknown error";
+        yield {
+          type: "error",
+          content: errorMsg,
+          ...budgetExceeded ? { code: "budget_exceeded" } : {},
+          ...m.usage ? {
+            usage: {
+              inputTokens: m.usage.input_tokens,
+              outputTokens: m.usage.output_tokens,
+              cacheCreationInputTokens: m.usage.cache_creation_input_tokens ?? undefined,
+              cacheReadInputTokens: m.usage.cache_read_input_tokens ?? undefined,
+              costUsd: m.total_cost_usd
+            }
+          } : {}
+        };
+        return;
+      }
+      if (message.type === "assistant") {
+        const m = message;
+        const content = m.message?.content ?? [];
+        const usage = m.message?.usage;
+        if (usage) {
+          lastContextTokens = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.output_tokens ?? 0);
+          lastContextModel = m.message.model;
+        }
+        for (const block of content) {
+          if (block.type === "text") {
+            const textBlock = block;
+            yield { type: "text", content: textBlock.text };
+            yield* extractFileEvents(textBlock.text, "text");
+          } else if (block.type === "tool_use") {
+            const tb = block;
+            yield {
+              type: "tool_use",
+              name: tb.name,
+              input: tb.input || {},
+              toolUseId: tb.id
+            };
+          }
+        }
+        continue;
+      }
+      if (message.type === "user") {
+        const um = message;
+        if ("isReplay" in um && um.isReplay)
+          continue;
+        const content = um.message?.content;
+        if (!Array.isArray(content))
+          continue;
+        for (const block of content) {
+          if (block.type !== "tool_result")
+            continue;
+          const trBlock = block;
+          const trContent = typeof trBlock.content === "string" ? trBlock.content.slice(0, 200) : "";
+          yield {
+            type: "tool_result",
+            toolUseId: trBlock.tool_use_id || "",
+            content: trContent
+          };
+        }
+      }
+    }
+  } catch (e) {
+    if (isAbortError(e) || opts.abortController?.signal.aborted)
+      return;
+    logger.error({ err: e }, "claudeProvider: SDK iteration failed");
+    yield { type: "error", content: errMsg(e) };
+  }
+}
+
+// ../../packages/core/src/agents/codex-provider.ts
+import { existsSync as existsSync7 } from "fs";
+import { Codex } from "@openai/codex-sdk";
+
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
+import { spawn as spawn2 } from "child_process";
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync5,
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { createRequire } from "module";
+import { dirname as dirname4, join as join6 } from "path";
+
+// ../../packages/core/src/version.ts
+var NEGOTIUM_VERSION = "0.1.13";
+
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
+var NEGOTIUM_MODEL_CATALOG = "negotium-model-catalog.json";
+var moduleRequire = createRequire(import.meta.url);
+function codexCliScriptPath() {
+  const sdkPackagePath = moduleRequire.resolve("@openai/codex-sdk/package.json");
+  const sdkRequire = createRequire(sdkPackagePath);
+  return join6(dirname4(sdkRequire.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}
+async function bootstrapCodexModelCache(codexHome, cachePath) {
+  const child = spawn2(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
+    env: { ...process.env, CODEX_HOME: codexHome },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  await new Promise((resolve4, reject) => {
+    let settled = false;
+    let stdoutBuffer = "";
+    let stderr = "";
+    const timer = setTimeout(() => finish(new Error("timed out while refreshing the Codex model catalog")), 15000);
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        child.stdin.end();
+        child.kill();
+      } catch {}
+      if (error)
+        reject(error);
+      else if (!existsSync5(cachePath))
+        reject(new Error("Codex did not create its model cache"));
+      else
+        resolve4();
+    };
+    const send = (message) => {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    };
+    child.stderr.on("data", (chunk) => {
+      if (stderr.length < 4096)
+        stderr += String(chunk);
+    });
+    child.on("error", (error) => finish(error));
+    child.on("exit", (code, signal) => {
+      if (!settled) {
+        finish(new Error(`Codex model catalog refresh exited with ${signal ? `signal ${signal}` : `code ${code ?? 1}`}${stderr.trim() ? `: ${stderr.trim()}` : ""}`));
+      }
+    });
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += String(chunk);
+      for (;; ) {
+        const newline = stdoutBuffer.indexOf(`
+`);
+        if (newline < 0)
+          break;
+        const line = stdoutBuffer.slice(0, newline);
+        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message.id === 1) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex initialization failed"));
+            return;
+          }
+          send({ method: "initialized" });
+          send({ id: 2, method: "model/list", params: { includeHidden: true } });
+        } else if (message.id === 2) {
+          if (message.error) {
+            finish(new Error(message.error.message || "Codex model listing failed"));
+          } else {
+            finish();
+          }
+          return;
+        }
+      }
+    });
+    send({
+      id: 1,
+      method: "initialize",
+      params: {
+        clientInfo: { name: "negotium", version: NEGOTIUM_VERSION },
+        capabilities: { experimentalApi: true }
+      }
+    });
+  });
+}
+async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexModelCache) {
+  const codexHome = dirname4(authFilePath);
+  const cachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? join6(codexHome, "models_cache.json");
+  const hardenedCatalogPath = join6(codexHome, NEGOTIUM_MODEL_CATALOG);
+  if (existsSync5(cachePath) || existsSync5(hardenedCatalogPath))
+    return;
+  if (process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE) {
+    throw new Error(`Configured Codex model cache does not exist: ${cachePath}`);
+  }
+  await bootstrap(codexHome, cachePath);
+}
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath) {
+  const codexHome = dirname4(authFilePath);
+  const sourcePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? (existsSync5(join6(codexHome, "models_cache.json")) ? join6(codexHome, "models_cache.json") : join6(codexHome, NEGOTIUM_MODEL_CATALOG));
+  const outputPath = join6(codexHome, NEGOTIUM_MODEL_CATALOG);
+  const parsed = JSON.parse(readFileSync5(sourcePath, "utf8"));
+  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
+    throw new Error(`Codex model cache has no models: ${sourcePath}`);
+  }
+  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}`);
+    }
+    return { ...model, multi_agent_version: "disabled" };
+  });
+  const contents = `${JSON.stringify({ models }, null, 2)}
+`;
+  if (existsSync5(outputPath) && readFileSync5(outputPath, "utf8") === contents) {
+    return outputPath;
+  }
+  const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync4(tempPath, contents, { encoding: "utf8", mode: 384 });
+    renameSync3(tempPath, outputPath);
+    chmodSync3(outputPath, 384);
+  } finally {
+    try {
+      unlinkSync3(tempPath);
+    } catch {}
+  }
+  return outputPath;
+}
+
+// ../../packages/core/src/agents/codex-tree-kill.ts
+import { execFileSync } from "child_process";
+var SIGKILL_DELAY_MS = 5000;
+var CODEX_PROC_NAME_MATCH = /codex/i;
+var TREE_DEPTH_CAP = 16;
+function getDirectChildren(parentPid) {
+  try {
+    const out = execFileSync("pgrep", ["-P", String(parentPid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!out)
+      return [];
+    return out.split(`
+`).map((s) => Number(s)).filter((n) => Number.isFinite(n) && n > 0);
+  } catch {
+    return [];
+  }
+}
+function getProcName(pid) {
+  try {
+    return execFileSync("ps", ["-p", String(pid), "-o", "comm="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function getProcLstart(pid) {
+  try {
+    return execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function collectTree(rootPid, out = new Set, depth = 0) {
+  if (out.has(rootPid))
+    return out;
+  out.add(rootPid);
+  if (depth >= TREE_DEPTH_CAP) {
+    logger.warn({ rootPid, depth, cap: TREE_DEPTH_CAP }, "codex-tree-kill: tree depth cap reached, descendants beyond this point not collected");
+    return out;
+  }
+  for (const child of getDirectChildren(rootPid)) {
+    collectTree(child, out, depth + 1);
+  }
+  return out;
+}
+function snapshotCodexChildren() {
+  const out = new Map;
+  for (const pid of getDirectChildren(process.pid)) {
+    const name = getProcName(pid);
+    if (!name || !CODEX_PROC_NAME_MATCH.test(name))
+      continue;
+    const lstart = getProcLstart(pid);
+    out.set(pid, lstart);
+  }
+  return out;
+}
+var globalOwnedCodexPids = new Set;
+function registerOwnedCodexPids(pids) {
+  for (const p of pids)
+    globalOwnedCodexPids.add(p);
+}
+function unregisterOwnedCodexPids(pids) {
+  for (const p of pids)
+    globalOwnedCodexPids.delete(p);
+}
+function findNewCodexChildren(baseline) {
+  const current = snapshotCodexChildren();
+  const novel = [];
+  for (const [pid, lstart] of current) {
+    const baselineLstart = baseline.get(pid);
+    if (baselineLstart !== undefined && baselineLstart === lstart)
+      continue;
+    if (globalOwnedCodexPids.has(pid))
+      continue;
+    novel.push(pid);
+  }
+  return novel;
+}
+var codexSpawnChain = Promise.resolve();
+async function acquireCodexSpawnLock() {
+  const prev = codexSpawnChain;
+  let release;
+  let released = false;
+  codexSpawnChain = new Promise((r) => {
+    release = () => {
+      if (released)
+        return;
+      released = true;
+      r();
+    };
+  });
+  await prev;
+  return release;
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSameProcess(pid, lstart) {
+  return lstart !== "" && isAlive(pid) && getProcLstart(pid) === lstart;
+}
+function signalCodexTrees(rootPids) {
+  if (rootPids.length === 0)
+    return null;
+  const targets = new Map;
+  for (const root of rootPids) {
+    for (const pid of collectTree(root)) {
+      if (!targets.has(pid))
+        targets.set(pid, getProcLstart(pid));
+    }
+  }
+  logger.warn({ rootPids, totalPids: targets.size }, "codex-tree-kill: SIGTERM process tree");
+  for (const pid of targets.keys()) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+  }
+  return { rootPids, targets };
+}
+function killCodexStragglers({ rootPids, targets }) {
+  const aliveTargets = [];
+  let droppedAsPossibleReuse = 0;
+  for (const [pid, lstart] of targets) {
+    if (isSameProcess(pid, lstart)) {
+      aliveTargets.push(pid);
+    } else if (isAlive(pid)) {
+      droppedAsPossibleReuse++;
+    }
+  }
+  if (aliveTargets.length === 0)
+    return;
+  const reachable = new Set(aliveTargets);
+  for (const root of rootPids) {
+    const rootLstart = targets.get(root);
+    if (rootLstart && isSameProcess(root, rootLstart)) {
+      for (const pid of collectTree(root))
+        reachable.add(pid);
+    }
+  }
+  const stragglers = [];
+  for (const pid of reachable) {
+    const lstart = targets.get(pid);
+    if (lstart && isSameProcess(pid, lstart))
+      stragglers.push(pid);
+    else if (isAlive(pid))
+      droppedAsPossibleReuse++;
+  }
+  logger.warn({
+    aliveRoots: rootPids.filter((pid) => {
+      const lstart = targets.get(pid);
+      return lstart ? isSameProcess(pid, lstart) : false;
+    }),
+    totalStragglers: stragglers.length,
+    droppedAsPossibleReuse
+  }, "codex-tree-kill: SIGKILL fallback after SIGTERM timeout");
+  for (const pid of stragglers) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {}
+  }
+}
+function killCodexTrees(rootPids) {
+  const plan = signalCodexTrees(rootPids);
+  if (!plan)
+    return;
+  const killTimer = setTimeout(() => {
+    killCodexStragglers(plan);
+  }, SIGKILL_DELAY_MS);
+  killTimer.unref?.();
+}
+
+// ../../packages/core/src/agents/rollout/codex.ts
+import { existsSync as existsSync6, readFileSync as readFileSync6, statSync as statSync2, unlinkSync as unlinkSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+function codexSessionsDir() {
+  return join7(process.env.CODEX_HOME || join7(homedir4(), ".codex"), "sessions");
+}
+function extractLatestCodexContextUsage(jsonl) {
+  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 !== "token_count")
+        continue;
+      const contextTokens = entry.payload.info?.last_token_usage?.total_tokens;
+      const contextWindow = entry.payload.info?.model_context_window;
+      if (typeof contextTokens === "number" && Number.isFinite(contextTokens) && contextTokens >= 0 && typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+        return { contextTokens, contextWindow };
+      }
+    } catch {}
+  }
+  return;
+}
+function readLatestCodexContextUsage(threadId) {
+  const sessionsDir = codexSessionsDir();
+  const candidates = [];
+  const buckets = candidateDateBuckets(threadId);
+  try {
+    if (buckets) {
+      for (const bucket of buckets) {
+        const dir = join7(sessionsDir, bucket);
+        if (!existsSync6(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          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(join7(sessionsDir, rel));
+      }
+    }
+    const path = candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
+    return path ? extractLatestCodexContextUsage(readFileSync6(path, "utf8")) : undefined;
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex context usage: rollout read failed");
+    return;
+  }
+}
+function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
+  const path = latestCodexRolloutPath(threadId);
+  if (!path)
+    return false;
+  try {
+    const entries = parseJsonlText(readFileSync6(path, "utf8"));
+    let changed = false;
+    for (const entry of entries) {
+      if (entry.type !== "session_meta" && entry.type !== "turn_context")
+        continue;
+      if (!entry.payload)
+        entry.payload = {};
+      if (entry.payload.multi_agent_version !== "disabled") {
+        entry.payload.multi_agent_version = "disabled";
+        changed = true;
+      }
+    }
+    if (changed) {
+      writeJsonlFile(path, entries);
+      logger.info({ threadId, path }, "codex rollout native multi-agent metadata disabled");
+    }
+    return changed;
+  } catch (error) {
+    logger.error({ error, threadId, path }, "codex rollout native multi-agent migration failed");
+    throw new Error(`Failed to migrate Codex rollout '${threadId}'`, { cause: error });
+  }
+}
+function latestCodexRolloutPath(threadId) {
+  const sessionsDir = codexSessionsDir();
+  const candidates = [];
+  const buckets = candidateDateBuckets(threadId);
+  try {
+    if (buckets) {
+      for (const bucket of buckets) {
+        const dir = join7(sessionsDir, bucket);
+        if (!existsSync6(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          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(join7(sessionsDir, rel));
+      }
+    }
+    return candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex rollout lookup failed");
+    return;
+  }
+}
+var MAX_DAY_SPAN = 30;
+var DAY_MS = 86400000;
+var LOCAL_DATE_SKEW_DAYS = 1;
+function candidateDateBuckets(threadId) {
+  const tidMs = decodeUuidV7Timestamp(threadId);
+  if (tidMs === null)
+    return null;
+  const nowMs = Date.now();
+  const tidDay = Math.floor(tidMs / DAY_MS);
+  const todayDay = Math.floor(nowMs / DAY_MS);
+  const minDay = Math.min(tidDay, todayDay);
+  const maxDay = Math.max(tidDay, todayDay);
+  const span = maxDay - minDay;
+  if (span > MAX_DAY_SPAN)
+    return null;
+  const buckets = new Set;
+  for (let d = minDay - LOCAL_DATE_SKEW_DAYS;d <= maxDay + LOCAL_DATE_SKEW_DAYS; d++) {
+    buckets.add(formatDateBucket(new Date(d * DAY_MS)));
+  }
+  return buckets;
+}
+function decodeUuidV7Timestamp(threadId) {
+  if (typeof threadId !== "string")
+    return null;
+  const m = /^([0-9a-fA-F]{8})-([0-9a-fA-F]{4})-7[0-9a-fA-F]{3}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.exec(threadId);
+  if (!m)
+    return null;
+  const hex = `${m[1]}${m[2]}`;
+  const ms = Number.parseInt(hex, 16);
+  if (!Number.isFinite(ms))
+    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/agents/codex-provider.ts
+function mapEffort(effort) {
+  if (!effort)
+    return;
+  if (effort === "max" || effort === "minimal") {
+    throw new Error(`codexProvider received effort='${effort}', which codex does not support \u2014 storage validation was bypassed`);
+  }
+  return effort;
+}
+var CODEX_MCP_SERVER_NAME_OVERRIDES = {
+  playwright: "otium_playwright"
+};
+function codexMcpServerName(name) {
+  return CODEX_MCP_SERVER_NAME_OVERRIDES[name] ?? name;
+}
+function parsePositiveInt(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+function withCodexMcpServerOverrides(name, server) {
+  if (name === "paddleocr") {
+    return {
+      ...server,
+      startup_timeout_sec: parsePositiveInt(process.env.PADDLEOCR_MCP_STARTUP_TIMEOUT_SEC, 30),
+      tool_timeout_sec: parsePositiveInt(process.env.PADDLEOCR_MCP_TOOL_TIMEOUT_SEC, 300)
+    };
+  }
+  return {
+    startup_timeout_sec: parsePositiveInt(process.env.CODEX_MCP_STARTUP_TIMEOUT_SEC, 30),
+    ...server
+  };
+}
+function toCodexMcpServers(claudeShape) {
+  const disabledBrowserStdio = () => ({
+    command: process.execPath,
+    args: ["-e", "process.exit(0)"],
+    enabled: false
+  });
+  const out = {
+    playwright: disabledBrowserStdio(),
+    "browser-rs": disabledBrowserStdio(),
+    patchright: disabledBrowserStdio()
+  };
+  for (const [name, srv] of Object.entries(claudeShape)) {
+    if (!srv || typeof srv !== "object")
+      continue;
+    const s = srv;
+    const codexName = codexMcpServerName(name);
+    if (typeof s.command === "string") {
+      out[codexName] = withCodexMcpServerOverrides(name, {
+        command: s.command,
+        ...Array.isArray(s.args) ? { args: s.args } : {},
+        ...s.env && typeof s.env === "object" ? { env: s.env } : {}
+      });
+      continue;
+    }
+    if (typeof s.url === "string" && s.type !== "sse") {
+      out[codexName] = withCodexMcpServerOverrides(name, {
+        url: s.url,
+        ...s.http_headers && typeof s.http_headers === "object" ? { http_headers: s.http_headers } : {},
+        ...s.env_http_headers && typeof s.env_http_headers === "object" ? { env_http_headers: s.env_http_headers } : {}
+      });
+    }
+  }
+  return out;
+}
+function isMissingCodexRolloutError(err) {
+  const msg = errMsg(err);
+  return /no rollout found|thread\/resume failed/i.test(msg);
+}
+function summarizeMcpToolCallResult(item) {
+  if (item.error)
+    return item.error.message.slice(0, 200);
+  if (!item.result)
+    return "";
+  const blocks = Array.isArray(item.result.content) ? item.result.content : [];
+  const text = blocks.map((b) => {
+    if (b && typeof b === "object" && "type" in b && b.type === "text" && "text" in b) {
+      return String(b.text ?? "");
+    }
+    return "";
+  }).filter(Boolean).join(`
+`);
+  if (text)
+    return text.slice(0, 200);
+  return JSON.stringify(item.result.structured_content ?? "").slice(0, 200);
+}
+function fileChangeEvents(item) {
+  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";
+    return [
+      {
+        type: "tool_use",
+        name,
+        input: { file_path: change.path, change_kind: change.kind },
+        toolUseId
+      },
+      {
+        type: "tool_result",
+        toolUseId,
+        content: success ? `${change.kind} applied: ${change.path}` : `${change.kind} failed: ${change.path}`
+      }
+    ];
+  });
+}
+function promptForThread(opts, includeSystemPrompt) {
+  return includeSystemPrompt && opts.systemPrompt ? `[System Instructions]
+${opts.systemPrompt}
+
+${opts.prompt}` : opts.prompt;
+}
+async function closeIterator(iter) {
+  try {
+    await iter.return?.();
+  } catch (err) {
+    logger.warn({ err }, "codexProvider: failed to close codex event iterator");
+  }
+}
+var CODEX_STARTUP_TIMEOUT_MS = 90000;
+async function startStreamedWithTracking(thread, prompt, abortSignal, trackedPids) {
+  const release = await acquireCodexSpawnLock();
+  try {
+    const baseline = snapshotCodexChildren();
+    const runResult = await thread.runStreamed(prompt, {
+      ...abortSignal ? { signal: abortSignal } : {}
+    });
+    const iter = runResult.events[Symbol.asyncIterator]();
+    let first;
+    let startupTimer;
+    try {
+      const startupTimeout = new Promise((_, reject) => {
+        startupTimer = setTimeout(() => reject(new Error(`Codex\uAC00 ${CODEX_STARTUP_TIMEOUT_MS / 1000}\uCD08 \uB0B4 \uC751\uB2F5\uC744 \uC2DC\uC791\uD558\uC9C0 \uC54A\uC544 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4. \uB2E4\uC2DC \uC2DC\uB3C4\uD574\uC8FC\uC138\uC694.`)), CODEX_STARTUP_TIMEOUT_MS);
+      });
+      const nextP = iter.next();
+      nextP.catch(() => {});
+      first = await Promise.race([nextP, startupTimeout]);
+    } catch (err) {
+      const novel2 = findNewCodexChildren(baseline);
+      if (novel2.length > 0) {
+        killCodexTrees(novel2);
+      }
+      await closeIterator(iter);
+      throw err;
+    } finally {
+      if (startupTimer)
+        clearTimeout(startupTimer);
+    }
+    const novel = findNewCodexChildren(baseline);
+    trackedPids.pids = novel;
+    registerOwnedCodexPids(novel);
+    return { iter, firstEvent: first.value, done: !!first.done };
+  } finally {
+    release();
+  }
+}
+function prependFirstEvent(iter, firstEvent, alreadyDone) {
+  return {
+    [Symbol.asyncIterator]() {
+      let emittedFirst = false;
+      let exhausted = alreadyDone;
+      return {
+        async next() {
+          if (!emittedFirst) {
+            emittedFirst = true;
+            if (alreadyDone)
+              return { value: undefined, done: true };
+            return { value: firstEvent, done: false };
+          }
+          if (exhausted)
+            return { value: undefined, done: true };
+          const r = await iter.next();
+          if (r.done)
+            exhausted = true;
+          return r;
+        },
+        async return(value) {
+          exhausted = true;
+          if (iter.return)
+            return iter.return(value);
+          return { value, done: true };
+        }
+      };
+    }
+  };
+}
+async function* codexProvider(opts) {
+  const codexAuthPath = hostedCodexAuthFilePath();
+  if (!existsSync7(codexAuthPath)) {
+    yield {
+      type: "error",
+      content: `Codex auth file not found at ${codexAuthPath}. Run \`codex login\` to authenticate.`
+    };
+    return;
+  }
+  let codexModelCatalogPath;
+  try {
+    await ensureCodexModelCache(codexAuthPath);
+    codexModelCatalogPath = writeCodexCatalogWithNativeMultiAgentDisabled(codexAuthPath);
+    if (opts.sessionId)
+      migrateCodexRolloutNativeMultiAgentMetadata(opts.sessionId);
+  } catch (err) {
+    yield {
+      type: "error",
+      content: `Failed to enforce the Codex native multi-agent policy: ${errMsg(err)}`
+    };
+    return;
+  }
+  const codexMcpServers = toCodexMcpServers(hostedMcpServers(opts));
+  const browserOwner = browserOwnerForContext(opts);
+  const scopedBrowserCapability = opts.playwrightCapability && browserOwner ? browserOwnerCapability(opts.playwrightCapability, browserOwner) : undefined;
+  logger.info({
+    model: opts.model ?? "(sdk default)",
+    effort: opts.effort ?? "(off)",
+    cwd: opts.cwd,
+    cwdExists: existsSync7(opts.cwd),
+    resume: Boolean(opts.sessionId),
+    mcpServerCount: Object.keys(codexMcpServers).length
+  }, "codexProvider: starting turn");
+  const codex = new Codex({
+    ...scopedBrowserCapability ? {
+      env: {
+        ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
+        [CODEX_BROWSER_CAPABILITY_ENV]: scopedBrowserCapability
+      }
+    } : {},
+    config: {
+      features: { multi_agent: false, multi_agent_v2: false, enable_fanout: false },
+      model_catalog_json: codexModelCatalogPath,
+      mcp_servers: codexMcpServers
+    }
+  });
+  const threadOptions = {
+    workingDirectory: opts.cwd,
+    skipGitRepoCheck: true,
+    sandboxMode: "danger-full-access",
+    approvalPolicy: "never",
+    ...opts.model ? { model: opts.model } : {},
+    ...opts.effort ? { modelReasoningEffort: mapEffort(opts.effort) } : {}
+  };
+  let currentSessionId = opts.sessionId;
+  let thread = currentSessionId ? codex.resumeThread(currentSessionId, threadOptions) : codex.startThread(threadOptions);
+  let prompt = promptForThread(opts, true);
+  let agentTextSoFar = "";
+  let currentAgentMessageId;
+  let finalText = "";
+  let stopReason = "end_turn";
+  const trackedPids = { pids: [] };
+  const abortSignal = opts.abortController?.signal;
+  const onAbortKill = () => {
+    if (trackedPids.pids.length > 0) {
+      killCodexTrees(trackedPids.pids);
+    }
+  };
+  abortSignal?.addEventListener("abort", onAbortKill, { once: true });
+  let heartbeatMs = 8 * 60 * 1000;
+  let heartbeatAttempts = 0;
+  const HEARTBEAT_MAX_MS = 16 * 60 * 1000;
+  const HEARTBEAT_MAX_ATTEMPTS = 2;
+  const HEARTBEAT_CONTINUATION = "\uACC4\uC18D \uC9C4\uD589\uD574\uC918.";
+  try {
+    while (true) {
+      if (abortSignal?.aborted)
+        return;
+      const attemptAbort = new AbortController;
+      const propagateOuter = () => attemptAbort.abort();
+      abortSignal?.addEventListener("abort", propagateOuter, { once: true });
+      trackedPids.pids = [];
+      let heartbeatTriggered = false;
+      let attemptCompleted = false;
+      let heartbeatTimer = null;
+      const scheduleHeartbeat = () => {
+        if (heartbeatTimer !== null)
+          clearTimeout(heartbeatTimer);
+        if (abortSignal?.aborted || attemptAbort.signal.aborted)
+          return;
+        heartbeatTimer = setTimeout(() => {
+          heartbeatTriggered = true;
+          if (trackedPids.pids.length > 0)
+            killCodexTrees(trackedPids.pids);
+          attemptAbort.abort();
+        }, heartbeatMs);
+      };
+      try {
+        scheduleHeartbeat();
+        let startResult;
+        try {
+          startResult = await startStreamedWithTracking(thread, prompt, attemptAbort.signal, trackedPids);
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError")
+            throw err;
+          if (!currentSessionId || !isMissingCodexRolloutError(err))
+            throw err;
+          logger.warn({ staleSessionId: currentSessionId, err: errMsg(err) }, "codexProvider: stale/missing rollout, restarting fresh thread");
+          thread = codex.startThread(threadOptions);
+          prompt = promptForThread(opts, true);
+          currentSessionId = undefined;
+          startResult = await startStreamedWithTracking(thread, prompt, attemptAbort.signal, trackedPids);
+        }
+        if (attemptAbort.signal.aborted) {
+          killCodexTrees(trackedPids.pids);
+          await closeIterator(startResult.iter);
+          throw Object.assign(new Error("heartbeat abort"), { name: "AbortError" });
+        }
+        const eventStream = prependFirstEvent(startResult.iter, startResult.firstEvent, startResult.done);
+        for await (const rawEvent of eventStream) {
+          scheduleHeartbeat();
+          const event = rawEvent;
+          switch (event.type) {
+            case "thread.started": {
+              if (event.thread_id) {
+                currentSessionId = event.thread_id;
+                yield { type: "session", sessionId: event.thread_id };
+              }
+              break;
+            }
+            case "item.started": {
+              const item = event.item;
+              if (!item)
+                break;
+              if (item.type === "command_execution") {
+                yield {
+                  type: "tool_use",
+                  name: "Bash",
+                  input: { command: String(item.command ?? "") },
+                  toolUseId: String(item.id ?? "")
+                };
+              } else if (item.type === "mcp_tool_call") {
+                yield {
+                  type: "tool_use",
+                  name: String(item.tool ?? "unknown"),
+                  input: item.arguments && typeof item.arguments === "object" ? item.arguments : {},
+                  toolUseId: String(item.id ?? "")
+                };
+              }
+              break;
+            }
+            case "item.updated": {
+              const item = event.item;
+              if (!item)
+                break;
+              if (item.type === "agent_message") {
+                const messageId = item.id != null ? String(item.id) : undefined;
+                if (messageId !== currentAgentMessageId) {
+                  currentAgentMessageId = messageId;
+                  agentTextSoFar = "";
+                }
+                const text = String(item.text ?? "");
+                const newChars = text.slice(agentTextSoFar.length);
+                if (newChars) {
+                  yield { type: "text_delta", content: newChars };
+                  agentTextSoFar = text;
+                }
+              }
+              break;
+            }
+            case "item.completed": {
+              const item = event.item;
+              if (!item)
+                break;
+              if (item.type === "agent_message") {
+                finalText = String(item.text ?? "");
+                agentTextSoFar = finalText;
+                yield { type: "text", content: finalText };
+                yield* extractFileEvents(finalText, "text");
+              } else if (item.type === "reasoning") {
+                const reasoning = String(item.text ?? "").trim();
+                if (reasoning)
+                  yield { type: "reasoning", content: reasoning };
+              } else if (item.type === "mcp_tool_call") {
+                yield {
+                  type: "tool_result",
+                  toolUseId: String(item.id ?? ""),
+                  content: summarizeMcpToolCallResult(item)
+                };
+              } else if (item.type === "command_execution") {
+                yield {
+                  type: "tool_result",
+                  toolUseId: String(item.id ?? ""),
+                  content: String(item.aggregated_output ?? "").slice(0, 200)
+                };
+              } else if (item.type === "file_change") {
+                for (const fileEvent of fileChangeEvents(item)) {
+                  yield fileEvent;
+                }
+              } else if (item.type === "error") {
+                yield { type: "error", content: String(item.message ?? "") };
+              }
+              break;
+            }
+            case "turn.completed": {
+              const usage = event.usage;
+              if (!usage)
+                break;
+              attemptCompleted = true;
+              const contextUsage = currentSessionId ? readLatestCodexContextUsage(currentSessionId) : undefined;
+              yield {
+                type: "result",
+                content: finalText,
+                stopReason,
+                usage: {
+                  inputTokens: usage.input_tokens,
+                  outputTokens: usage.output_tokens,
+                  cacheReadInputTokens: usage.cached_input_tokens,
+                  ...contextUsage
+                }
+              };
+              if (finalText)
+                yield* extractFileEvents(finalText, "result");
+              break;
+            }
+            case "turn.failed": {
+              stopReason = "error";
+              yield {
+                type: "error",
+                content: event.error?.message || "Codex turn failed"
+              };
+              break;
+            }
+            default:
+              break;
+          }
+        }
+      } catch (err) {
+        if (abortSignal?.aborted)
+          return;
+        if (err instanceof Error && err.name === "AbortError") {
+          if (!heartbeatTriggered)
+            return;
+        } else {
+          logger.error({ err }, "codexProvider: attempt failed");
+          yield { type: "error", content: errMsg(err) };
+          break;
+        }
+      } finally {
+        if (heartbeatTimer !== null)
+          clearTimeout(heartbeatTimer);
+        abortSignal?.removeEventListener("abort", propagateOuter);
+        if (trackedPids.pids.length > 0)
+          unregisterOwnedCodexPids(trackedPids.pids);
+      }
+      if (attemptCompleted || abortSignal?.aborted)
+        break;
+      if (!heartbeatTriggered)
+        break;
+      heartbeatAttempts++;
+      if (heartbeatAttempts > HEARTBEAT_MAX_ATTEMPTS) {
+        logger.warn({ attempts: heartbeatAttempts }, "codexProvider: max heartbeat attempts reached");
+        yield {
+          type: "error",
+          content: `Codex\uAC00 ${HEARTBEAT_MAX_ATTEMPTS}\uD68C \uC7AC\uC2DC\uB3C4 \uD6C4\uC5D0\uB3C4 \uC751\uB2F5\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`
+        };
+        break;
+      }
+      heartbeatMs = Math.min(heartbeatMs * 2, HEARTBEAT_MAX_MS);
+      logger.info({ attempt: heartbeatAttempts, nextIntervalMs: heartbeatMs }, "codexProvider: heartbeat fired, resuming thread with continuation prompt");
+      agentTextSoFar = "";
+      finalText = "";
+      thread = currentSessionId ? codex.resumeThread(currentSessionId, threadOptions) : codex.startThread(threadOptions);
+      prompt = currentSessionId ? HEARTBEAT_CONTINUATION : promptForThread(opts, true);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError")
+      return;
+    if (abortSignal?.aborted)
+      return;
+    logger.error({ err }, "codexProvider: setup failed");
+    yield { type: "error", content: errMsg(err) };
+  } finally {
+    abortSignal?.removeEventListener("abort", onAbortKill);
+    if (trackedPids.pids.length > 0)
+      unregisterOwnedCodexPids(trackedPids.pids);
+  }
+}
+
+// ../../packages/core/src/platform/maestro-bootstrap-env.ts
+process.env.MAESTRO_SDK_SILENT_BOOTSTRAP ??= "1";
+
+// ../../packages/core/src/agents/maestro-provider.ts
+import { maestroProvider as sdkMaestroProvider, setMcpResolver } from "maestro-agent-sdk";
+var MAESTRO_DEFAULT_MAX_TOKENS = 32768;
+var PROVIDER_ASK_USER_TOOL = "AskUserQuestion";
+var PROVIDER_SUBAGENT_TOOL = "Agent";
+var MAESTRO_NATIVE_TASK_TOOLS = [
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskList",
+  "TaskGet",
+  "TaskOutput",
+  "TaskStop"
+];
+var MAESTRO_PROVIDER_OWNED_TOOL_SET = new Set([
+  PROVIDER_ASK_USER_TOOL,
+  PROVIDER_SUBAGENT_TOOL,
+  ...MAESTRO_NATIVE_TASK_TOOLS
+]);
+var DEFAULT_MAESTRO_DISALLOWED_TOOLS = [
+  PROVIDER_ASK_USER_TOOL,
+  PROVIDER_SUBAGENT_TOOL,
+  ...MAESTRO_NATIVE_TASK_TOOLS
+];
+function buildMaestroDisallowedTools(callerDisallowedTools = []) {
+  return [...new Set([...DEFAULT_MAESTRO_DISALLOWED_TOOLS, ...callerDisallowedTools])];
+}
+function buildVaultHook(userId) {
+  return {
+    name: "vault-guard",
+    pre({ toolName, input }) {
+      if (referencesHostedSecretStorage(input)) {
+        return { decision: "block", error: "Runtime secret storage access is not permitted" };
+      }
+      if (shouldRedirectHostedVaultTool(userId, toolName, input)) {
+        return { decision: "block", error: VAULT_BROKER_REDIRECT_ERROR };
+      }
+      return { decision: "allow" };
+    },
+    post({ output }) {
+      const redacted = redactHostedSecrets(userId, output);
+      return redacted === output ? {} : { output: redacted };
+    }
+  };
+}
+function buildMaestroToolHooks(userId) {
+  return [buildVaultHook(userId), buildProviderOwnedToolBlockHook()];
+}
+function providerOwnedToolRedirect(toolName) {
+  if (toolName === PROVIDER_ASK_USER_TOOL) {
+    return "Use the runtime ask_user_question MCP tool instead.";
+  }
+  if (toolName === PROVIDER_SUBAGENT_TOOL) {
+    return "Use the runtime spawn_subagent MCP tool instead.";
+  }
+  return "Use the shared task MCP tools instead " + "(mcp__task__task_create / task_update / task_list / task_get / task_delete).";
+}
+function buildProviderOwnedToolBlockHook() {
+  return {
+    name: "provider-owned-tool-redirect",
+    pre({ toolName }) {
+      if (!MAESTRO_PROVIDER_OWNED_TOOL_SET.has(toolName))
+        return { decision: "allow" };
+      return {
+        decision: "block",
+        error: `${toolName} is disabled in this environment. ${providerOwnedToolRedirect(toolName)}`
+      };
+    }
+  };
+}
+function maestroProvider(opts) {
+  if (opts.agent !== undefined && opts.agent !== "maestro") {
+    throw new Error(`maestroProvider: unexpected agent "${opts.agent}", expected "maestro"`);
+  }
+  const userId = opts.userId ?? "";
+  setMcpResolver(hostedMcpServers);
+  const callerDisallowedTools = opts.disallowedTools ?? [];
+  const callerToolHooks = opts.toolHooks ?? [];
+  const sdkOpts = {
+    enableBackgroundBash: false,
+    maxTokens: MAESTRO_DEFAULT_MAX_TOKENS,
+    enableToolSearch: true,
+    ...opts,
+    agent: "maestro",
+    disallowedTools: buildMaestroDisallowedTools(callerDisallowedTools),
+    toolHooks: [...buildMaestroToolHooks(userId), ...callerToolHooks]
+  };
+  return sdkMaestroProvider(sdkOpts);
+}
 
 // ../../packages/core/src/agents/hosted-agent.ts
 async function* runHostedAgent(input, host) {
@@ -61,4 +3056,4 @@ export {
   configureAgentExecutionHost
 };
 
-//# debugId=D187F007DFA0700264756E2164756E21
+//# debugId=F7C9A771B460541764756E2164756E21