negotium 0.1.18 → 0.1.20

package/dist/agent-helpers.js

@@ -41,6 +41,10 @@ function parseRuntimePort(value, fallback) {
   const port = Number.parseInt(value, 10);
   return Number.isInteger(port) && port > 0 && port <= 65535 ? port : fallback;
 }
+function safeRuntimePathSegment(value, fallback, maxLength = 160) {
+  const cleaned = value.trim().replace(/[^A-Za-z0-9._-]/g, "_").replace(/^_+|_+$/g, "").slice(0, maxLength);
+  return cleaned || fallback;
+}
 
 // ../../packages/core/src/platform/logger.ts
 import pino from "pino";
@@ -141,6 +145,12 @@ var BACKGROUND_BASH_SERVER = resolve(PROJECT_ROOT, "src/mcp/background-bash-serv
 var VAULT_SERVER = resolve(PROJECT_ROOT, "src/mcp/vault-server.ts");
 var BG_BASH_BASE_PORT = parsePortEnv(process.env.BG_BASH_BASE_PORT, 9700);
 var BG_BASH_MAX_PORT = parsePortEnv(process.env.BG_BASH_MAX_PORT, 9799);
+function safeWorkspaceSegment(value, fallback) {
+  return safeRuntimePathSegment(value, fallback);
+}
+function resolveTopicWorkspaceDir(topicId) {
+  return join(TOPIC_WORKSPACE_DIR, safeWorkspaceSegment(topicId, "topic"));
+}
 function loadOrCreateLocalSecret(envKey, filename, options = {}) {
   const envValue = envText(envKey);
   const secretFile = resolve(STATE_DIR, filename);
@@ -214,6 +224,7 @@ 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";
@@ -226,6 +237,9 @@ function resolveModelEnv(envKey, agentConst) {
 }
 var SESSION_MODEL = resolveModelEnv("SESSION_MODEL", SESSION_AGENT);
 var GATEWAY_MODEL = resolveModelEnv("GATEWAY_MODEL", GATEWAY_AGENT);
+function resolveDefaultModel(agent, registryDefaultModel) {
+  return agent === SESSION_AGENT && SESSION_MODEL ? SESSION_MODEL : registryDefaultModel;
+}
 var FFMPEG_BIN = envText("FFMPEG_BIN");
 var FFPROBE_BIN = envText("FFPROBE_BIN");
 var PYTHON_BIN = envText("PYTHON_BIN") ?? "python3";
@@ -672,13 +686,72 @@ var defaultSafeUnlink = createSafeUnlink({
   unlink: unlinkSync,
   warn: (context, message) => logger.warn(context, message)
 });
+function safeUnlink(path, warnLabel) {
+  defaultSafeUnlink(path, warnLabel);
+}
 
 // ../../packages/core/src/platform/jsonl.ts
 function parseJsonlText(raw) {
   return raw.trim().split(`
 `).filter(Boolean).map((line) => JSON.parse(line));
 }
+var LOCK_SUFFIX = ".lock";
+var LOCK_RETRY_MS = 5;
+var LOCK_TIMEOUT_MS = 1500;
+var LOCK_STALE_MS = 5000;
 var LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function sleepForAppendLock(ms) {
+  Atomics.wait(LOCK_SLEEP, 0, 0, ms);
+}
+function tryAcquireAppendLock(lockPath) {
+  try {
+    closeSync(openSync(lockPath, "wx"));
+    return true;
+  } catch (e) {
+    if (e.code !== "EEXIST")
+      throw e;
+    return false;
+  }
+}
+function isStaleLock(lockPath) {
+  try {
+    return Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+function appendJsonlLine(filePath, line) {
+  mkdirSync3(dirname3(filePath), { recursive: true });
+  const lockPath = `${filePath}${LOCK_SUFFIX}`;
+  const payload = line.endsWith(`
+`) ? line : `${line}
+`;
+  let acquired = tryAcquireAppendLock(lockPath);
+  if (!acquired && isStaleLock(lockPath)) {
+    safeUnlink(lockPath);
+    acquired = tryAcquireAppendLock(lockPath);
+  }
+  if (!acquired) {
+    const start = Date.now();
+    while (!acquired && Date.now() - start < LOCK_TIMEOUT_MS) {
+      sleepForAppendLock(LOCK_RETRY_MS);
+      acquired = tryAcquireAppendLock(lockPath);
+      if (!acquired && isStaleLock(lockPath)) {
+        safeUnlink(lockPath);
+        acquired = tryAcquireAppendLock(lockPath);
+      }
+    }
+  }
+  if (!acquired) {
+    appendFileSync(filePath, payload);
+    return;
+  }
+  try {
+    appendFileSync(filePath, payload);
+  } finally {
+    safeUnlink(lockPath);
+  }
+}
 function writeJsonlFile(filePath, entries) {
   const dir = dirname3(filePath);
   mkdirSync3(dir, { recursive: true });
@@ -987,6 +1060,106 @@ function patchEnvContext(envContext, cwd, currentDate, timezone) {
     }
   }
 }
+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 = join6(sessionsDir, bucket);
+        if (!existsSync5(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          candidates.push(join6(dir, rel));
+        }
+      }
+    } else {
+      const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+      for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
+        candidates.push(join6(sessionsDir, rel));
+      }
+    }
+    const path = candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
+    return path ? extractLatestCodexContextUsage(readFileSync4(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(readFileSync4(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 = join6(sessionsDir, bucket);
+        if (!existsSync5(dir))
+          continue;
+        const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
+        for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
+          candidates.push(join6(dir, rel));
+        }
+      }
+    }
+    if (candidates.length === 0) {
+      const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
+      for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
+        candidates.push(join6(sessionsDir, rel));
+      }
+    }
+    return candidates.sort((a, b) => statSync2(b).mtimeMs - statSync2(a).mtimeMs)[0];
+  } catch (error) {
+    logger.debug({ error, threadId }, "codex rollout lookup failed");
+    return;
+  }
+}
 function writeCodexRollout(opts) {
   const threadId = opts.threadId ?? uuidv7();
   assertUuidLike("threadId", threadId);
@@ -1281,6 +1454,9 @@ function defaultStateDir() {
 function defaultDataDir() {
   return envPath("NEGOTIUM_DATA_DIR", join7(defaultStateDir(), "data"));
 }
+function defaultWorkspaceDir() {
+  return envPath("NEGOTIUM_WORKSPACE_DIR", join7(defaultStateDir(), "workspace"));
+}
 function defaultSessionsDatabasePath() {
   return envPath("SESSIONS_DB_PATH", join7(resolveStorageDataDir(), "sessions.db"));
 }
@@ -1311,6 +1487,16 @@ function resolveStorageDatabase() {
 function resolveStorageDataDir() {
   return configuredHost.dataDir ?? defaultDataDir();
 }
+function resolveStorageWorkspaceDir() {
+  return configuredHost.workspaceDir ?? defaultWorkspaceDir();
+}
+function resolveStorageSharedWikiDir() {
+  return configuredHost.sharedWikiDir ?? join7(resolveStorageWorkspaceDir(), "wiki");
+}
+function registerStorageSchemaInitializer(initialize, priority = 100) {
+  schemaInitializers.push({ initialize, priority });
+  schemaInitializers.sort((a, b) => a.priority - b.priority);
+}
 function ensureStorageSchemas(database = resolveStorageDatabase()) {
   if (initializingDatabases.has(database))
     return;
@@ -1368,6 +1554,23 @@ function topicFilename(topicName) {
 function getConversationPath(userId, topicName) {
   return join8(conversationDir(userId), topicFilename(topicName));
 }
+function appendConversationEvent(userId, topicName, agent, event) {
+  try {
+    appendConversationEventStrict(userId, topicName, agent, event);
+  } catch (err) {
+    logger.warn({ err, userId, topicName, eventType: event.type }, "appendConversationEvent: write failed");
+  }
+}
+function appendConversationEventStrict(userId, topicName, agent, event) {
+  const path = getConversationPath(userId, topicName);
+  const entry = {
+    ts: new Date().toISOString(),
+    agent,
+    event
+  };
+  mkdirSync6(dirname5(path), { recursive: true });
+  appendJsonlLine(path, JSON.stringify(entry));
+}
 function readConversation(userId, topicName) {
   const path = getConversationPath(userId, topicName);
   const out = [];
@@ -1520,82 +1723,40 @@ async function forkAgentSession(opts) {
 function cleanupAgentFork(handle) {
   defaultForkHelpers.cleanupAgentFork(handle);
 }
-// ../../packages/core/src/storage/tasks.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync6, renameSync as renameSync4, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname6, join as join10 } from "path";
-function safeUserIdComponent2(userId) {
-  const str = String(userId);
-  if (!str || /[/\\]|\.\./.test(str)) {
-    throw new Error(`tasks: refusing unsafe userId path component: ${str}`);
-  }
-  return str;
-}
-function safeTaskScopeKey(scopeKey) {
-  const safe = sanitizeFileName(scopeKey);
-  if (!safe || safe === "." || safe === "..") {
-    throw new Error(`tasks: refusing unsafe scope key: ${scopeKey}`);
-  }
-  return safe;
-}
-function taskScopeKey(opts) {
-  return opts.topicId?.trim() || opts.session || "default";
-}
-function getTaskFilePath(userId, scopeKey) {
-  return join10(resolveStorageDataDir(), "tasks", safeUserIdComponent2(userId), `${safeTaskScopeKey(scopeKey)}.json`);
-}
-function readTasks(userId, scopeKey) {
-  const path = getTaskFilePath(userId, scopeKey);
-  if (!existsSync8(path))
-    return [];
-  try {
-    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
-    return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
-  } catch (e) {
-    logger.warn({ err: e, path }, "tasks: failed to read task store");
-    return [];
-  }
-}
-function taskFileMtimeNs(userId, scopeKey) {
-  try {
-    return statSync3(getTaskFilePath(userId, scopeKey), { bigint: true }).mtimeNs;
-  } catch {
-    return null;
-  }
-}
+// ../../packages/core/src/agents/archiver.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync10, statSync as statSync4 } from "fs";
+import { join as join15 } from "path";
 
-// ../../packages/core/src/agents/task-events.ts
-var defaultTaskEventHost = { readTasks, taskFileMtimeNs, taskScopeKey };
-function resolveTaskEventScope(opts, host = defaultTaskEventHost) {
-  if (opts.silent)
-    return null;
-  if (!opts.userId)
-    return null;
-  if (opts.sessionType === "dm" || opts.sessionType === "ephemeral") {
-    return { userId: opts.userId, scopeKey: "dm" };
-  }
-  if (opts.sessionType === "manager") {
-    return { userId: opts.userId, scopeKey: opts.topicId ?? "general" };
-  }
-  if (!opts.session)
-    return null;
-  return {
-    userId: opts.userId,
-    scopeKey: host.taskScopeKey({ topicId: opts.topicId, session: opts.session })
-  };
-}
-async function* withTaskSnapshots(inner, scope, host = defaultTaskEventHost) {
-  let lastMtime = host.taskFileMtimeNs(scope.userId, scope.scopeKey);
-  for await (const event of inner) {
-    yield event;
-    if (event.type !== "tool_result" && event.type !== "result")
-      continue;
-    const mtime = host.taskFileMtimeNs(scope.userId, scope.scopeKey);
-    if (mtime === lastMtime)
-      continue;
-    lastMtime = mtime;
-    yield { type: "tasks", tasks: host.readTasks(scope.userId, scope.scopeKey) };
+// ../../packages/core/src/agents/index.ts
+import { existsSync as existsSync12 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join13 } from "path";
+
+// ../../packages/core/src/agents/claude-provider.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+// ../../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 resolve4 } from "path";
@@ -1627,9 +1788,56 @@ function isSensitivePath(filePath) {
 }
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync8 } from "fs";
-import { join as join11 } from "path";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync7 } from "fs";
+import { join as join10 } from "path";
+
+// ../../packages/core/src/storage/vault-crypto.ts
+import { createCipheriv, createDecipheriv, createHash, randomBytes as randomBytes3 } 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 = randomBytes3(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");
@@ -1664,8 +1872,8 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const path = join11(dataDir, "vault.db");
-  mkdirSync8(dataDir, { recursive: true });
+  const path = join10(dataDir, "vault.db");
+  mkdirSync7(dataDir, { recursive: true });
   const database = new Database(path, { create: true });
   chmodSync2(path, 384);
   initializeVaultDatabase(database);
@@ -1680,9 +1888,38 @@ 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 vaultSubstituteDetailed(userId, text) {
+  const entries = new Map(vaultListWithValues(userId).map((entry) => [entry.key, entry.value]));
+  const usedKeys = new Set;
+  const substituted = text.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+    const key = normalizeVaultKey(rawKey);
+    const value = entries.get(key);
+    if (value === undefined)
+      return match;
+    usedKeys.add(key);
+    return value;
+  });
+  return { text: substituted, usedKeys: [...usedKeys] };
+}
 function valueReferencesVaultKey(userId, value) {
   const keys = new Set(vaultList(userId).map((entry) => entry.key));
   const visit = (candidate) => {
@@ -1702,6 +1939,44 @@ function valueReferencesVaultKey(userId, value) {
   };
   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 = [
@@ -1738,15 +2013,4232 @@ var defaultVaultToolPolicy = createVaultToolPolicy({ isSensitivePath, valueRefer
 var isVaultBrokerTool = defaultVaultToolPolicy.isVaultBrokerTool;
 var referencesRuntimeSecretStorage = defaultVaultToolPolicy.referencesRuntimeSecretStorage;
 var shouldRedirectVaultTool = defaultVaultToolPolicy.shouldRedirectVaultTool;
+
+// ../../packages/core/src/platform/mcp-config.ts
+import { createHmac as createHmac3 } from "crypto";
+
+// ../../packages/core/src/mcp/canonical-bridge-config.ts
+var registrations = [];
+var turnLeases = new Map;
+function turnKey(scope) {
+  return JSON.stringify([
+    scope.userId,
+    scope.topicId,
+    scope.queryId,
+    scope.peerBridge.hubCellId,
+    scope.peerBridge.hostTopicId,
+    scope.peerBridge.hostQueryId
+  ]);
+}
+function canonicalMcpBridgeEnv(scope) {
+  const lease = registrations.at(-1)?.provider(scope);
+  if (!lease)
+    return;
+  const key = turnKey(scope);
+  const leases = turnLeases.get(key) ?? new Set;
+  leases.add(lease.revoke);
+  turnLeases.set(key, leases);
+  return lease.env;
+}
+
+// ../../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 registrations2 = [];
+function peerSessionBridgeIpcEnv() {
+  const active = registrations2.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/background-bash/manager.ts
+import { execFileSync as execFileSync3, spawn } from "child_process";
+import { randomBytes as randomBytes4 } from "crypto";
+
+// ../../packages/core/src/platform/delay.ts
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ../../packages/core/src/platform/background-bash/context.ts
+import { createHmac as createHmac2 } from "crypto";
+function deriveBgBashContextCapability(runtimeCapability, userId, topic) {
+  return createHmac2("sha256", runtimeCapability).update(`${userId}\x00${topic}`).digest("hex");
+}
+
+// ../../packages/core/src/platform/background-bash/manager.ts
+function makeBgBashKey(_userId, _topic) {
+  return "runtime";
+}
+function defaultPortPids(port) {
+  try {
+    return execFileSync3("lsof", ["-i", `:${port}`, "-t"], { stdio: "pipe" }).toString().trim().split(`
+`).map((pid) => Number.parseInt(pid, 10)).filter((pid) => !Number.isNaN(pid));
+  } catch {
+    return [];
+  }
+}
+function createBackgroundBashManager(options = {}) {
+  const instances = new Map;
+  const usedPorts = new Set;
+  const spawning = new Map;
+  const knownContexts = new Map;
+  const runtimeCapability = options.capability ?? randomBytes4(32).toString("hex");
+  const runtimeServerId = options.serverId ?? randomBytes4(16).toString("hex");
+  const serverFile = options.serverFile ?? BACKGROUND_BASH_SERVER;
+  const basePort = options.basePort ?? BG_BASH_BASE_PORT;
+  const maxPort = options.maxPort ?? BG_BASH_MAX_PORT;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const now = options.now ?? Date.now;
+  const wait = options.delay ?? delay;
+  const portPids = options.portPids ?? defaultPortPids;
+  const spawnImpl = options.spawn ?? ((command, args, spawnOptions) => spawn(command, [...args], spawnOptions));
+  function contextKey(userId, topic) {
+    return `${userId}\x00${topic}`;
+  }
+  function contextCapability(userId, topic) {
+    return deriveBgBashContextCapability(runtimeCapability, userId, topic);
+  }
+  async function allocatePort(excludedPorts = new Set) {
+    for (let port = basePort;port <= maxPort; port++) {
+      if (usedPorts.has(port) || excludedPorts.has(port))
+        continue;
+      usedPorts.add(port);
+      if (portPids(port).length > 0) {
+        usedPorts.delete(port);
+        continue;
+      }
+      return port;
+    }
+    throw new Error(`No available ports for background-bash (range ${basePort}-${maxPort}, ${instances.size} active)`);
+  }
+  async function isHealthy(port) {
+    try {
+      const response = await fetchImpl(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(2000)
+      });
+      return response.ok && await response.text() === runtimeServerId;
+    } catch {
+      return false;
+    }
+  }
+  function killRuntime() {
+    const key = "runtime";
+    const instance = instances.get(key);
+    if (!instance)
+      return;
+    try {
+      instance.process.kill("SIGTERM");
+    } catch {}
+    usedPorts.delete(instance.port);
+    instances.delete(key);
+    logger.info({ key, port: instance.port }, "background-bash server killed");
+  }
+  async function spawnServer(key, reservedPort, excludedPorts = new Set) {
+    const port = reservedPort ?? await allocatePort(excludedPorts);
+    const process2 = spawnImpl("bun", ["run", serverFile, `--port=${port}`], {
+      stdio: "ignore",
+      detached: false,
+      env: {
+        ...options.env ?? globalThis.process.env,
+        NEGOTIUM_BG_BASH_CAPABILITY: runtimeCapability,
+        NEGOTIUM_BG_BASH_SERVER_ID: runtimeServerId
+      }
+    });
+    process2.once("error", (error) => {
+      logger.error({ err: error, key }, "background-bash server error");
+      if (instances.get(key)?.process === process2) {
+        usedPorts.delete(port);
+        instances.delete(key);
+      }
+    });
+    process2.once("exit", (code) => {
+      logger.info({ key, code }, "background-bash server exited");
+      if (instances.get(key)?.process === process2) {
+        usedPorts.delete(port);
+        instances.delete(key);
+      }
+    });
+    const timestamp = now();
+    instances.set(key, { process: process2, port, startedAt: timestamp, lastUsedAt: timestamp });
+    const started = now();
+    while (now() - started < 8000) {
+      if (process2.exitCode !== null) {
+        const nextExcluded = new Set(excludedPorts);
+        nextExcluded.add(port);
+        return spawnServer(key, undefined, nextExcluded);
+      }
+      if (await isHealthy(port))
+        return port;
+      await wait(200);
+    }
+    killRuntime();
+    throw new Error(`background-bash server failed health check after spawn on port ${port}`);
+  }
+  async function ensure(userId, topic) {
+    const key = makeBgBashKey(userId, topic);
+    knownContexts.set(contextKey(userId, topic), { userId, topic });
+    const inProgress = spawning.get(key);
+    if (inProgress)
+      return inProgress;
+    const promise = (async () => {
+      const existing = instances.get(key);
+      if (existing && !existing.process.killed && existing.process.exitCode === null) {
+        if (await isHealthy(existing.port)) {
+          existing.lastUsedAt = now();
+          return existing.port;
+        }
+        killRuntime();
+      } else if (existing) {
+        usedPorts.delete(existing.port);
+        instances.delete(key);
+      }
+      return spawnServer(key);
+    })().finally(() => spawning.delete(key));
+    spawning.set(key, promise);
+    return promise;
+  }
+  function clear(userId, topic) {
+    knownContexts.delete(contextKey(userId, topic));
+    const instance = instances.get("runtime");
+    if (!instance)
+      return;
+    const query = new URLSearchParams({
+      user: userId,
+      topic,
+      capability: contextCapability(userId, topic)
+    });
+    fetchImpl(`http://127.0.0.1:${instance.port}/contexts?${query}`, {
+      method: "DELETE"
+    }).catch(() => {});
+  }
+  function clearUser(userId) {
+    for (const context of [...knownContexts.values()]) {
+      if (context.userId === userId)
+        clear(context.userId, context.topic);
+    }
+  }
+  async function killAll() {
+    const entries = [...instances.values()];
+    for (const instance of entries) {
+      try {
+        instance.process.kill("SIGTERM");
+      } catch {}
+    }
+    instances.clear();
+    usedPorts.clear();
+    knownContexts.clear();
+    const deadline = now() + 3000;
+    await Promise.all(entries.map((instance) => new Promise((resolve5) => {
+      if (instance.process.exitCode !== null || instance.process.killed)
+        return resolve5();
+      instance.process.once("exit", resolve5);
+      instance.process.once("error", resolve5);
+      const timer = setTimeout(resolve5, Math.max(0, deadline - now()));
+      timer.unref?.();
+    })));
+  }
+  return { contextCapability, ensure, clear, clearUser, killAll };
+}
+var defaultManager = createBackgroundBashManager();
+var bgBashContextCapability = defaultManager.contextCapability;
+var ensureBgBash = defaultManager.ensure;
+var killBgBash = defaultManager.clear;
+var killBgBashForUser = defaultManager.clearUser;
+var killAllBgBash = defaultManager.killAll;
+
+// ../../packages/core/src/platform/mcp-catalog-policy.ts
+var COMMON_RUNTIME_MCP_POLICY = {
+  playwright: { scopes: ["dm", "forum", "fork", "cron"], forumRequired: true },
+  runtime: { scopes: ["forum", "manager", "fork", "cron"], forumRequired: true },
+  "token-stats": { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true },
+  task: { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true },
+  "session-comm": { scopes: ["forum", "fork", "manager"], forumRequired: true },
+  wiki: { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true },
+  skills: { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true },
+  "system-health": { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true },
+  "background-bash": { scopes: ["forum"], forumRequired: true },
+  "agent-health": { scopes: ["forum", "manager", "cron"], forumRequired: true },
+  vault: { scopes: ["dm", "forum", "manager", "cron"], forumRequired: true }
+};
+function classifyForumMcpServers(catalog) {
+  const all = Object.entries(catalog).filter(([, entry]) => entry.scopes.includes("forum")).map(([name]) => name);
+  const required = Object.entries(catalog).filter(([, entry]) => entry.scopes.includes("forum") && entry.forumRequired).map(([name]) => name);
+  const requiredSet = new Set(required);
+  return { all, required, optional: all.filter((name) => !requiredSet.has(name)) };
+}
+function commonRuntimeMcpPolicy(name) {
+  return COMMON_RUNTIME_MCP_POLICY[name];
+}
+
+// ../../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 createHmac3("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` };
+}
+function backgroundBashTransport(agent, port, userId, topic) {
+  const capability = bgBashContextCapability(userId, topic);
+  const headers = {
+    "X-Background-Bash-User": userId,
+    "X-Background-Bash-Topic": topic,
+    "X-Background-Bash-Capability": capability
+  };
+  if (agent === "codex")
+    return { url: `http://127.0.0.1:${port}/mcp`, http_headers: headers };
+  if (agent === "maestro") {
+    const query = new URLSearchParams({ user: userId, topic, capability });
+    return { type: "sse", url: `http://127.0.0.1:${port}/sse?${query}` };
+  }
+  return { type: "sse", url: `http://127.0.0.1:${port}/sse`, headers };
+}
+var MCP_CATALOG = {
+  playwright: {
+    ...commonRuntimeMcpPolicy("playwright"),
+    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]: {
+    ...commonRuntimeMcpPolicy("runtime"),
+    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
+      });
+    }
+  },
+  "token-stats": {
+    ...commonRuntimeMcpPolicy("token-stats"),
+    build({ userId, agent }) {
+      return buildStdioMcpServer(agent, TOKEN_STATS_SERVER, [`--user-id=${userId}`]);
+    }
+  },
+  task: {
+    ...commonRuntimeMcpPolicy("task"),
+    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": {
+    ...commonRuntimeMcpPolicy("session-comm"),
+    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: {
+    ...commonRuntimeMcpPolicy("wiki"),
+    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: {
+    ...commonRuntimeMcpPolicy("skills"),
+    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": {
+    ...commonRuntimeMcpPolicy("system-health"),
+    build({ agent }) {
+      return buildStdioMcpServer(agent, SYSTEM_HEALTH_SERVER, []);
+    }
+  },
+  "background-bash": {
+    ...commonRuntimeMcpPolicy("background-bash"),
+    build({ agent, bgBashPort, userId, topicId, session }) {
+      const topic = topicId ?? session;
+      if (bgBashPort === undefined || !topic)
+        return null;
+      return backgroundBashTransport(agent, bgBashPort, userId, topic);
+    }
+  },
+  "agent-health": {
+    ...commonRuntimeMcpPolicy("agent-health"),
+    build({ userId, agent }) {
+      const args = [`--user-id=${userId}`];
+      return buildStdioMcpServer(agent, AGENT_HEALTH_SERVER, args);
+    }
+  },
+  vault: {
+    ...commonRuntimeMcpPolicy("vault"),
+    build({ userId, agent }) {
+      const args = [`--user-id=${userId}`, "--list-only=true"];
+      return buildStdioMcpServer(agent, VAULT_SERVER, args);
+    }
+  }
+};
+var allForumMcpServerNames = [];
+var requiredForumMcpServers = [];
+var REQUIRED_FORUM_MCP_SERVERS = requiredForumMcpServers;
+var optionalForumMcpServers = [];
+function refreshForumCatalogViews() {
+  const { all, required, optional } = classifyForumMcpServers(MCP_CATALOG);
+  allForumMcpServerNames.splice(0, allForumMcpServerNames.length, ...all);
+  requiredForumMcpServers.splice(0, requiredForumMcpServers.length, ...required);
+  optionalForumMcpServers.splice(0, optionalForumMcpServers.length, ...optional);
+}
+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,
+  substituteVaultSecrets: (userId, value) => vaultSubstituteDetailed(userId, value).text,
+  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 hostedMcpServers(opts) {
+  return activeHost().getMcpServersForQuery(opts);
+}
+function redactHostedSecrets(userId, value) {
+  return activeHost().redactVaultSecrets(userId, value);
+}
+function substituteHostedSecrets(userId, value) {
+  return activeHost().substituteVaultSecrets(userId, value);
+}
+function referencesHostedSecretStorage(value) {
+  return activeHost().referencesRuntimeSecretStorage(value);
+}
+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/runtime/context-warning.ts
+function claudeRequestContextTokens(usage) {
+  const values = [
+    usage.input_tokens,
+    usage.cache_creation_input_tokens,
+    usage.cache_read_input_tokens,
+    usage.output_tokens
+  ];
+  if (values.every((value) => value === undefined || value === null))
+    return null;
+  if (values.some((value) => value !== undefined && value !== null && (!Number.isFinite(value) || value < 0))) {
+    return null;
+  }
+  return values.reduce((sum, value) => sum + (value ?? 0), 0);
+}
+
+// ../../packages/core/src/agents/claude-provider.ts
+var CLAUDE_DEFAULT_DISALLOWED_TOOLS = [
+  "AskUserQuestion",
+  "Workflow",
+  "TodoWrite",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskList",
+  "TaskGet"
+];
+var CLAUDE_NATIVE_AGENT_TOOLS = ["Task", "Agent", "TaskOutput", "TaskStop"];
+function substituteClaudeToolInput(userId, input) {
+  return deepMapStrings(input, (value) => substituteHostedSecrets(userId, value));
+}
+function buildClaudeDisallowedTools(extra = undefined) {
+  return [
+    ...new Set([
+      ...CLAUDE_DEFAULT_DISALLOWED_TOOLS,
+      ...CLAUDE_NATIVE_AGENT_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: readFileSync6(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 = spawn2(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 && !existsSync8(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 ??= "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 ?? "";
+              const withVault = substituteClaudeToolInput(userId, tool_input);
+              if (JSON.stringify(withVault) === JSON.stringify(tool_input)) {
+                return { continue: true };
+              }
+              return {
+                hookSpecificOutput: {
+                  hookEventName: "PreToolUse",
+                  updatedInput: withVault
+                }
+              };
+            }
+          ]
+        }
+      ],
+      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 = claudeRequestContextTokens(usage) ?? undefined;
+          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 existsSync10 } from "fs";
+import { Codex } from "@openai/codex-sdk";
+
+// ../../packages/core/src/agents/codex-native-multi-agent.ts
+import { spawn as spawn3 } from "child_process";
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync9,
+  readFileSync as readFileSync7,
+  renameSync as renameSync4,
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { createRequire } from "module";
+import { dirname as dirname6, join as join11 } from "path";
+
+// ../../packages/core/src/version.ts
+var NEGOTIUM_VERSION = "0.1.20";
+
+// ../../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 join11(dirname6(sdkRequire.resolve("@openai/codex/package.json")), "bin", "codex.js");
+}
+async function bootstrapCodexModelCache(codexHome, cachePath) {
+  const child = spawn3(process.execPath, [codexCliScriptPath(), "app-server", "--stdio"], {
+    env: { ...process.env, CODEX_HOME: codexHome },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  await new Promise((resolve5, reject) => {
+    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 (!existsSync9(cachePath))
+        reject(new Error("Codex did not create its model cache"));
+      else
+        resolve5();
+    };
+    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 = dirname6(authFilePath);
+  const cachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? join11(codexHome, "models_cache.json");
+  const hardenedCatalogPath = join11(codexHome, NEGOTIUM_MODEL_CATALOG);
+  if (existsSync9(cachePath) || existsSync9(hardenedCatalogPath))
+    return;
+  if (process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE) {
+    throw new Error(`Configured Codex model cache does not exist: ${cachePath}`);
+  }
+  await bootstrap(codexHome, cachePath);
+}
+function writeCodexCatalogWithNativeMultiAgentDisabled(authFilePath) {
+  const codexHome = dirname6(authFilePath);
+  const sourcePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE ?? (existsSync9(join11(codexHome, "models_cache.json")) ? join11(codexHome, "models_cache.json") : join11(codexHome, NEGOTIUM_MODEL_CATALOG));
+  const outputPath = join11(codexHome, NEGOTIUM_MODEL_CATALOG);
+  const parsed = JSON.parse(readFileSync7(sourcePath, "utf8"));
+  if (!Array.isArray(parsed.models) || parsed.models.length === 0) {
+    throw new Error(`Codex model cache has no models: ${sourcePath}`);
+  }
+  const 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 (existsSync9(outputPath) && readFileSync7(outputPath, "utf8") === contents) {
+    return outputPath;
+  }
+  const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
+    renameSync4(tempPath, outputPath);
+    chmodSync3(outputPath, 384);
+  } finally {
+    try {
+      unlinkSync8(tempPath);
+    } catch {}
+  }
+  return outputPath;
+}
+
+// ../../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) {
+  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 (!existsSync10(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: existsSync10(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/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({ input }) {
+      if (referencesHostedSecretStorage(input)) {
+        return { decision: "block", error: "Runtime secret storage access is not permitted" };
+      }
+      const substituted = deepMapStrings(input, (value) => substituteHostedSecrets(userId, value));
+      return JSON.stringify(substituted) === JSON.stringify(input) ? { decision: "allow" } : { decision: "modify", input: substituted };
+    },
+    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/storage/tasks.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync8, renameSync as renameSync5, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join12 } from "path";
+function safeUserIdComponent2(userId) {
+  const str = String(userId);
+  if (!str || /[/\\]|\.\./.test(str)) {
+    throw new Error(`tasks: refusing unsafe userId path component: ${str}`);
+  }
+  return str;
+}
+function safeTaskScopeKey(scopeKey) {
+  const safe = sanitizeFileName(scopeKey);
+  if (!safe || safe === "." || safe === "..") {
+    throw new Error(`tasks: refusing unsafe scope key: ${scopeKey}`);
+  }
+  return safe;
+}
+function taskScopeKey(opts) {
+  return opts.topicId?.trim() || opts.session || "default";
+}
+function getTaskFilePath(userId, scopeKey) {
+  return join12(resolveStorageDataDir(), "tasks", safeUserIdComponent2(userId), `${safeTaskScopeKey(scopeKey)}.json`);
+}
+function readTasks(userId, scopeKey) {
+  const path = getTaskFilePath(userId, scopeKey);
+  if (!existsSync11(path))
+    return [];
+  try {
+    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
+  } catch (e) {
+    logger.warn({ err: e, path }, "tasks: failed to read task store");
+    return [];
+  }
+}
+function taskFileMtimeNs(userId, scopeKey) {
+  try {
+    return statSync3(getTaskFilePath(userId, scopeKey), { bigint: true }).mtimeNs;
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/core/src/agents/task-events.ts
+var defaultTaskEventHost = { readTasks, taskFileMtimeNs, taskScopeKey };
+function resolveTaskEventScope(opts, host = defaultTaskEventHost) {
+  if (opts.silent)
+    return null;
+  if (!opts.userId)
+    return null;
+  if (opts.sessionType === "dm" || opts.sessionType === "ephemeral") {
+    return { userId: opts.userId, scopeKey: "dm" };
+  }
+  if (opts.sessionType === "manager") {
+    return { userId: opts.userId, scopeKey: opts.topicId ?? "general" };
+  }
+  if (!opts.session)
+    return null;
+  return {
+    userId: opts.userId,
+    scopeKey: host.taskScopeKey({ topicId: opts.topicId, session: opts.session })
+  };
+}
+async function* withTaskSnapshots(inner, scope, host = defaultTaskEventHost) {
+  let lastMtime = host.taskFileMtimeNs(scope.userId, scope.scopeKey);
+  for await (const event of inner) {
+    yield event;
+    if (event.type !== "tool_result" && event.type !== "result")
+      continue;
+    const mtime = host.taskFileMtimeNs(scope.userId, scope.scopeKey);
+    if (mtime === lastMtime)
+      continue;
+    lastMtime = mtime;
+    yield { type: "tasks", tasks: host.readTasks(scope.userId, scope.scopeKey) };
+  }
+}
+
+// ../../packages/core/src/agents/index.ts
+async function* dispatchAgent(opts) {
+  switch (opts.agent) {
+    case "claude":
+      yield* claudeProvider(opts);
+      return;
+    case "codex":
+      yield* codexProvider(opts);
+      return;
+    case "maestro":
+      yield* maestroProvider(opts);
+      return;
+    default: {
+      const exhaustive = opts.agent;
+      throw new Error(`runAgent: unknown agent '${exhaustive}'`);
+    }
+  }
+}
+function shouldRecordTurn(opts) {
+  return !opts.silent && typeof opts.userId === "string" && opts.userId.length > 0 && typeof opts.session === "string" && opts.session.length > 0;
+}
+function hasSessionRepairContext(opts) {
+  return typeof opts.userId === "string" && opts.userId.length > 0 && typeof opts.session === "string" && opts.session.length > 0;
+}
+async function resolveSessionFileMissing(agent, sessionId, cwd) {
+  switch (agent) {
+    case "claude": {
+      const encodedCwd = encodeClaudeCwd(cwd);
+      const path = join13(homedir8(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
+      return !existsSync12(path);
+    }
+    case "codex": {
+      const sessionsDir = join13(process.env.CODEX_HOME || join13(homedir8(), ".codex"), "sessions");
+      const glob = new Bun.Glob(`**/rollout-*-${sessionId}.jsonl`);
+      for await (const _rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
+        return false;
+      }
+      return true;
+    }
+    case "maestro": {
+      const path = join13(homedir8(), ".maestro", "sessions", `${sessionId}.jsonl`);
+      return !existsSync12(path);
+    }
+    default: {
+      const _exhaustive = agent;
+      return false;
+    }
+  }
+}
+async function maybeRebuildSession(opts) {
+  if (!opts.sessionId)
+    return true;
+  try {
+    const missing = await resolveSessionFileMissing(opts.agent, opts.sessionId, opts.cwd);
+    if (!missing)
+      return true;
+    logger.info({ agent: opts.agent, sessionId: opts.sessionId, topic: opts.session }, "session file missing \u2014 rebuilding from unified log");
+    const entries = readConversation(opts.userId, opts.session);
+    if (entries.length === 0) {
+      logger.info({ agent: opts.agent, sessionId: opts.sessionId }, "no unified log entries to rebuild \u2014 starting fresh session");
+      return false;
+    }
+    const registry = getRegistry(opts.agent);
+    const result = registry.writeRollout({
+      cwd: opts.cwd,
+      entries,
+      reuseSessionId: opts.sessionId,
+      ...opts.model ? { model: opts.model } : {},
+      ...opts.effort ? { effort: opts.effort } : {}
+    });
+    logger.info({ agent: opts.agent, sessionId: result.sessionId, rolloutPath: result.rolloutPath }, "session rebuilt from unified log");
+    return true;
+  } catch (err) {
+    logger.warn({ err, agent: opts.agent, sessionId: opts.sessionId }, "session rebuild failed \u2014 starting fresh session");
+    return false;
+  }
+}
+async function* runAgent(opts) {
+  const recording = shouldRecordTurn(opts);
+  const dispatchOpts = { ...opts };
+  if (hasSessionRepairContext(dispatchOpts)) {
+    const ok = await maybeRebuildSession(dispatchOpts);
+    if (!ok) {
+      dispatchOpts.sessionId = undefined;
+    }
+  }
+  const taskScope = resolveTaskEventScope(dispatchOpts);
+  const stream = taskScope ? withTaskSnapshots(dispatchAgent(dispatchOpts), taskScope) : dispatchAgent(dispatchOpts);
+  for await (const event of stream) {
+    if (recording && event.type !== "tasks") {
+      appendConversationEvent(opts.userId, opts.session, opts.agent, event);
+    }
+    yield event;
+  }
+}
+
+// ../../packages/core/src/bus.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// ../../packages/core/src/storage/forum-db.ts
+var db = internalStorageDatabase;
+
+// ../../packages/core/src/storage/runtime-events.ts
+var RUNTIME_EVENT_TYPES = [
+  "message",
+  "message-updated",
+  "ai-status",
+  "topic-created",
+  "topic-updated",
+  "topic-deleted"
+];
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_events (
+    seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_id TEXT NOT NULL,
+    event_type TEXT NOT NULL CHECK (
+      event_type IN (
+        'message',
+        'message-updated',
+        'ai-status',
+        'topic-created',
+        'topic-updated',
+        'topic-deleted'
+      )
+    ),
+    topic_id TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_events_topic_seq ON runtime_events(topic_id, seq)");
+var types = new Set(RUNTIME_EVENT_TYPES);
+function rowToEvent(row) {
+  if (!types.has(row.event_type))
+    return null;
+  try {
+    return {
+      seq: Number(row.seq),
+      sourceId: row.source_id,
+      type: row.event_type,
+      topicId: row.topic_id,
+      payload: JSON.parse(row.payload_json),
+      createdAt: row.created_at
+    };
+  } catch {
+    return null;
+  }
+}
+function latestRuntimeEventSeq() {
+  const row = db.query("SELECT MAX(seq) AS seq FROM runtime_events").get();
+  return Number(row?.seq ?? 0);
+}
+function appendRuntimeEvent(sourceId, event) {
+  const createdAt = new Date().toISOString();
+  const result = db.query(`INSERT INTO runtime_events
+         (source_id, event_type, topic_id, payload_json, created_at)
+       VALUES (?, ?, ?, ?, ?)`).run(sourceId, event.type, event.topicId, JSON.stringify(event.payload ?? null), createdAt);
+  const seq = Number(result.lastInsertRowid);
+  return { seq, sourceId, ...event, createdAt };
+}
+function listRuntimeEventsAfter(seq, limit = 500) {
+  const rows = db.query(`SELECT seq, source_id, event_type, topic_id, payload_json, created_at
+       FROM runtime_events
+       WHERE seq > ?
+       ORDER BY seq ASC
+       LIMIT ?`).all(Math.max(0, seq), Math.max(1, Math.min(limit, 5000)));
+  return rows.map(rowToEvent).filter((event) => event !== null);
+}
+
+// ../../packages/core/src/bus.ts
+class SqliteRuntimeBus {
+  listeners = new Set;
+  sourceId;
+  pollIntervalMs;
+  cursor;
+  pollTimer = null;
+  polling = false;
+  constructor(options = {}) {
+    this.sourceId = options.sourceId ?? `${process.pid}-${randomUUID2()}`;
+    this.pollIntervalMs = Math.max(25, options.pollIntervalMs ?? 100);
+    this.cursor = latestRuntimeEventSeq();
+  }
+  deliver(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {}
+    }
+  }
+  emit(event) {
+    const stored = appendRuntimeEvent(this.sourceId, event);
+    this.deliver({ ...event, seq: stored.seq, createdAt: stored.createdAt });
+  }
+  startPolling() {
+    if (this.pollTimer)
+      return;
+    this.pollTimer = setInterval(() => this.poll(), this.pollIntervalMs);
+    this.pollTimer.unref?.();
+    this.poll();
+  }
+  stopPolling() {
+    if (!this.pollTimer)
+      return;
+    clearInterval(this.pollTimer);
+    this.pollTimer = null;
+  }
+  poll() {
+    if (this.polling || this.listeners.size === 0)
+      return;
+    this.polling = true;
+    try {
+      while (true) {
+        const events = listRuntimeEventsAfter(this.cursor);
+        if (events.length === 0)
+          break;
+        for (const event of events) {
+          this.cursor = Math.max(this.cursor, event.seq);
+          if (event.sourceId === this.sourceId)
+            continue;
+          this.deliver({
+            type: event.type,
+            topicId: event.topicId,
+            payload: event.payload,
+            seq: event.seq,
+            createdAt: event.createdAt
+          });
+        }
+        if (events.length < 500)
+          break;
+      }
+    } finally {
+      this.polling = false;
+    }
+  }
+  broadcastMessage(topicId, message) {
+    this.emit({ type: "message", topicId, payload: message });
+  }
+  broadcastMessageUpdated(topicId, messageId, patch) {
+    this.emit({ type: "message-updated", topicId, payload: { messageId, patch } });
+  }
+  broadcastAiStatus(topicId, status) {
+    this.emit({ type: "ai-status", topicId, payload: status });
+  }
+  broadcastTopicCreated(topic) {
+    this.emit({ type: "topic-created", topicId: topic.id, payload: topic });
+  }
+  broadcastTopicUpdated(topicId) {
+    this.emit({ type: "topic-updated", topicId, payload: null });
+  }
+  broadcastTopicDeleted(topicId) {
+    this.emit({ type: "topic-deleted", topicId, payload: null });
+  }
+  broadcastAiActive(topicId, queryId) {
+    this.broadcastAiStatus(topicId, { kind: "ai_active", queryId });
+  }
+  broadcastDone(topicId, queryId, usage, meta) {
+    this.broadcastAiStatus(topicId, {
+      kind: "ai_done",
+      queryId,
+      usage,
+      agent: meta?.agent,
+      model: meta?.model
+    });
+  }
+  broadcastError(topicId, queryId, error) {
+    this.broadcastAiStatus(topicId, { kind: "ai_error", queryId, error });
+  }
+  broadcastAborted(topicId, queryId, reason) {
+    this.broadcastAiStatus(topicId, { kind: "ai_aborted", queryId, reason });
+  }
+  broadcastToolCall(topicId, queryId, name, input, label, toolUseId) {
+    const id = toolUseId.trim() || `${queryId}:tool`;
+    this.broadcastAiStatus(topicId, {
+      kind: "tool_call",
+      queryId,
+      name,
+      input,
+      label,
+      toolUseId: id
+    });
+  }
+  broadcastToolOutput(topicId, queryId, toolUseId, content) {
+    const id = toolUseId.trim() || `${queryId}:tool`;
+    this.broadcastAiStatus(topicId, { kind: "tool_output", queryId, toolUseId: id, content });
+  }
+  broadcastToolStatus(topicId, queryId, kind, content, meta) {
+    this.broadcastAiStatus(topicId, {
+      kind: "tool_status",
+      queryId,
+      statusKind: kind,
+      content,
+      toolName: meta?.toolName,
+      elapsed: meta?.elapsed
+    });
+  }
+  broadcastFileReady(topicId, queryId, path, source) {
+    this.broadcastAiStatus(topicId, { kind: "file_ready", queryId, path, source });
+  }
+  broadcastReasoning(topicId, queryId, content) {
+    this.broadcastAiStatus(topicId, { kind: "reasoning", queryId, content });
+  }
+  broadcastVisual(topicId, queryId, url, id, title, kind) {
+    this.broadcastAiStatus(topicId, { kind: "visual", queryId, url, id, title, visualKind: kind });
+  }
+  broadcastTyping(topicId, userId) {
+    this.broadcastAiStatus(topicId, { kind: "typing", userId });
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.startPolling();
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0)
+        this.stopPolling();
+    };
+  }
+}
+var current = new SqliteRuntimeBus;
+var WsHub = {
+  get() {
+    return current;
+  }
+};
+
+// ../../packages/core/src/prompts/builders.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve5 } from "path";
+var PROMPTS_DIR = resolve5(PROJECT_ROOT, "src/prompts");
+var SESSIONS_DIR = resolve5(PROMPTS_DIR, "sessions");
+function loadAgentPrompt(filename) {
+  const raw = readFileSync9(resolve5(AGENTS_PROMPTS_DIR, filename), "utf-8");
+  const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match)
+    throw new Error(`Agent prompt ${filename} is missing frontmatter`);
+  const meta = {};
+  let currentKey = null;
+  for (const line of match[1].split(`
+`)) {
+    if (/^\w[^:]*:$/.test(line)) {
+      currentKey = line.trim().replace(/:$/, "");
+      meta[currentKey] = [];
+    } else if (line.startsWith("  - ") && currentKey) {
+      meta[currentKey].push(line.slice(4).trim());
+    } else if (line.trim() !== "" && line.includes(":") && !line.startsWith(" ")) {
+      currentKey = null;
+      const colonIdx = line.indexOf(":");
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (key && value)
+        meta[key] = value;
+    }
+  }
+  return {
+    name: String(meta.name ?? filename.replace(".md", "")),
+    type: meta.type ?? "programmatic",
+    model: meta.model ? String(meta.model) : undefined,
+    tools: Array.isArray(meta.tools) ? meta.tools : undefined,
+    description: meta.description ? String(meta.description) : undefined,
+    prompt: match[2].trim()
+  };
+}
+
+// ../../packages/core/src/storage/api-messages.ts
+function initializeApiMessagesSchema() {
+  db.exec(`
+  CREATE TABLE IF NOT EXISTS api_messages (
+    id TEXT PRIMARY KEY,
+    topic_id TEXT NOT NULL,
+    parent_id TEXT,
+    author_id TEXT NOT NULL,
+    source_adapter TEXT,
+    source_node TEXT,
+    source_message_id TEXT,
+    text TEXT NOT NULL,
+    query_id TEXT,
+    agent_type TEXT,
+    model TEXT,
+    attachments TEXT,
+    usage TEXT,
+    deleted INTEGER NOT NULL DEFAULT 0,
+    edited_at TEXT,
+    reactions TEXT,
+    kind TEXT,
+    ask_user_question TEXT,
+    mentions TEXT,
+    thread_root_id TEXT,
+    created_at TEXT NOT NULL
+  )
+`);
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN source_adapter TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN source_node TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN source_message_id TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN deleted INTEGER NOT NULL DEFAULT 0");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN edited_at TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN reactions TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN kind TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN ask_user_question TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN mentions TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN thread_root_id TEXT");
+  } catch {}
+  try {
+    db.exec("ALTER TABLE api_messages ADD COLUMN subagent_card TEXT");
+  } catch {}
+  db.exec("CREATE INDEX IF NOT EXISTS idx_api_messages_topic ON api_messages(topic_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_api_messages_thread_root ON api_messages(thread_root_id)");
+}
+registerStorageSchemaInitializer(initializeApiMessagesSchema, 30);
+var appendHooks = new Set;
+function emitApiMessageAppended(msg) {
+  for (const hook of appendHooks) {
+    queueMicrotask(() => {
+      try {
+        Promise.resolve(hook(msg)).catch(() => {
+          return;
+        });
+      } catch {}
+    });
+  }
+}
+function appendApiMessage(msg, options = {}) {
+  const notify = options.notify ?? true;
+  const updateTopicLastMessageAt = options.updateTopicLastMessageAt ?? true;
+  let inserted = false;
+  db.transaction(() => {
+    const result = db.query(`INSERT INTO api_messages
+         (id, topic_id, parent_id, author_id, source_adapter, source_node, source_message_id, text, query_id, agent_type, model, attachments, usage, deleted, edited_at, reactions, kind, ask_user_question, subagent_card, mentions, thread_root_id, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO NOTHING`).run(msg.id, msg.topicId, msg.parentId ?? null, msg.authorId, msg.sourceAdapter ?? null, msg.sourceNode ?? null, msg.sourceMessageId ?? null, msg.text, msg.queryId ?? null, msg.agentType ?? null, msg.model ?? null, msg.attachments ? JSON.stringify(msg.attachments) : null, msg.usage ? JSON.stringify(msg.usage) : null, msg.deleted ? 1 : 0, msg.editedAt ?? null, msg.reactions?.length ? JSON.stringify(msg.reactions) : null, msg.kind ?? null, msg.askUserQuestion ? JSON.stringify(msg.askUserQuestion) : null, msg.subagentCard ? JSON.stringify(msg.subagentCard) : null, msg.mentions?.length ? JSON.stringify(msg.mentions) : null, msg.threadRootId ?? null, msg.createdAt);
+    inserted = Number(result.changes ?? 0) > 0;
+    if (inserted && updateTopicLastMessageAt && !msg.deleted) {
+      db.query(`UPDATE api_topics
+         SET last_message_at = CASE
+           WHEN last_message_at IS NULL OR last_message_at < ? THEN ?
+           ELSE last_message_at
+         END
+         WHERE id = ?`).run(msg.createdAt, msg.createdAt, msg.topicId);
+    }
+  })();
+  if (inserted && notify && !msg.deleted)
+    emitApiMessageAppended(msg);
+}
+function getAllMessagesForTopic(topicId) {
+  return db.query("SELECT *, rowid AS rowid FROM api_messages WHERE topic_id = ? AND deleted = 0 ORDER BY rowid ASC").all(topicId);
+}
+function getMessagesForTopicAfterRowid(topicId, afterRowid) {
+  return db.query("SELECT *, rowid AS rowid FROM api_messages WHERE topic_id = ? AND rowid > ? AND deleted = 0 ORDER BY rowid ASC").all(topicId, afterRowid);
+}
+
+// ../../packages/core/src/storage/api-topic-brief.ts
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS api_topic_brief (
+      topic_id TEXT PRIMARY KEY,
+      brief_md TEXT NOT NULL DEFAULT '',
+      latest_summary_md TEXT,
+      summary_date TEXT,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+}, 30);
+function rowToBrief(r) {
+  return {
+    topicId: r.topic_id,
+    briefMd: r.brief_md,
+    latestSummaryMd: r.latest_summary_md ?? undefined,
+    summaryDate: r.summary_date ?? undefined,
+    updatedAt: r.updated_at
+  };
+}
+function getTopicBrief(topicId) {
+  const row = db.query("SELECT topic_id, brief_md, latest_summary_md, summary_date, updated_at FROM api_topic_brief WHERE topic_id = ?").get(topicId);
+  if (!row)
+    return null;
+  return rowToBrief(row);
+}
+function setTopicBrief(topicId, fields) {
+  const existing = getTopicBrief(topicId);
+  const briefMd = fields.briefMd !== undefined ? fields.briefMd : existing?.briefMd ?? "";
+  const latestSummaryMd = fields.latestSummaryMd !== undefined ? fields.latestSummaryMd : existing?.latestSummaryMd ?? null;
+  const summaryDate = fields.summaryDate !== undefined ? fields.summaryDate : existing?.summaryDate ?? null;
+  db.query(`INSERT INTO api_topic_brief
+       (topic_id, brief_md, latest_summary_md, summary_date, updated_at)
+       VALUES (?, ?, ?, ?, datetime('now'))
+     ON CONFLICT(topic_id) DO UPDATE SET
+       brief_md = excluded.brief_md,
+       latest_summary_md = excluded.latest_summary_md,
+       summary_date = excluded.summary_date,
+       updated_at = excluded.updated_at`).run(topicId, briefMd, latestSummaryMd, summaryDate);
+  return getTopicBrief(topicId);
+}
+
+// ../../packages/core/src/storage/wiki.ts
+import { basename, dirname as dirname8, join as join14 } from "path";
+function getSharedWikiDir(workspaceDir = resolveStorageWorkspaceDir()) {
+  return workspaceDir === resolveStorageWorkspaceDir() ? resolveStorageSharedWikiDir() : join14(workspaceDir, "wiki");
+}
+
+// ../../packages/core/src/storage/wiki-summary-names.ts
+function wikiSummarySlug(value) {
+  return value.replaceAll(/[^a-zA-Z0-9\uAC00-\uD7A3_-]+/g, "-").slice(0, 120) || "_";
+}
+function isEphemeralWikiTopicId(topicId) {
+  return topicId?.startsWith("__") ?? false;
+}
+function wikiSummaryStorageSlug(rawTopic, topicId) {
+  return topicId && !isEphemeralWikiTopicId(topicId) ? wikiSummarySlug(topicId) : wikiSummarySlug(rawTopic);
+}
+function wikiSummaryFilename(date, rawTopic, topicId) {
+  return `${date}-${wikiSummaryStorageSlug(rawTopic, topicId)}.md`;
+}
+
+// ../../packages/core/src/topics/personal-general.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+// ../../packages/core/src/platform/constants.ts
+var FROM_AUTO_CONTINUE = "auto-continue";
+var FROM_SELF_SCHEDULE = "self-schedule";
+var RESERVED_TOPIC_NAMES = new Set([
+  FROM_AUTO_CONTINUE,
+  FROM_SELF_SCHEDULE,
+  "general"
+]);
+var GENERAL_TOPIC_ID = "general";
+
+// ../../packages/core/src/storage/api-topic-config.ts
+function tableColumns(table) {
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return new Set(rows.map((row) => row.name));
+}
+function createCanonicalConfigTable(name = "api_topic_config") {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${name} (
+      topic_id TEXT PRIMARY KEY REFERENCES api_topics(id) ON DELETE CASCADE,
+      model TEXT,
+      effort TEXT CHECK (effort IS NULL OR effort IN ('low','medium','high','xhigh','max')),
+      mcp TEXT,
+      agent_locked INTEGER NOT NULL DEFAULT 0 CHECK (agent_locked IN (0,1)),
+      model_locked INTEGER NOT NULL DEFAULT 0 CHECK (model_locked IN (0,1)),
+      effort_locked INTEGER NOT NULL DEFAULT 0 CHECK (effort_locked IN (0,1))
+    )
+  `);
+}
+function initializeApiTopicConfigSchema() {
+  const existingConfigColumns = tableColumns("api_topic_config");
+  if (existingConfigColumns.size === 0) {
+    createCanonicalConfigTable();
+  } else if (existingConfigColumns.has("agent") || existingConfigColumns.has("agent_pinned") || existingConfigColumns.has("runtime_locked") || existingConfigColumns.has("model_pinned") || existingConfigColumns.has("effort_pinned") || existingConfigColumns.has("last_shown_agent")) {
+    const topicColumns = tableColumns("api_topics");
+    const agentColumn = topicColumns.has("agent") ? "agent" : topicColumns.has("runtime_agent") ? "runtime_agent" : null;
+    if (agentColumn && existingConfigColumns.has("agent")) {
+      db.exec(`UPDATE api_topics
+       SET ${agentColumn} = (
+         SELECT c.agent FROM api_topic_config c WHERE c.topic_id = api_topics.id
+       )
+       WHERE ${agentColumn} IS NULL
+         AND EXISTS (
+           SELECT 1 FROM api_topic_config c
+           WHERE c.topic_id = api_topics.id AND c.agent IS NOT NULL
+         )`);
+    }
+    const previousForeignKeys = db.query("PRAGMA foreign_keys").get()?.foreign_keys;
+    db.exec("PRAGMA foreign_keys = OFF");
+    try {
+      const agentLockSource = existingConfigColumns.has("runtime_locked") ? "runtime_locked" : existingConfigColumns.has("agent_pinned") ? "agent_pinned" : "0";
+      const modelLockSource = existingConfigColumns.has("model_locked") ? "model_locked" : existingConfigColumns.has("model_pinned") ? "model_pinned" : "0";
+      const effortLockSource = existingConfigColumns.has("effort_locked") ? "effort_locked" : existingConfigColumns.has("effort_pinned") ? "effort_pinned" : "0";
+      db.transaction(() => {
+        createCanonicalConfigTable("api_topic_config_next");
+        db.exec(`
+        INSERT INTO api_topic_config_next
+          (topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked)
+        SELECT
+          topic_id,
+          model,
+          effort,
+          mcp,
+          COALESCE(${agentLockSource}, 0),
+          COALESCE(${modelLockSource}, 0),
+          COALESCE(${effortLockSource}, 0)
+        FROM api_topic_config
+        WHERE EXISTS (SELECT 1 FROM api_topics t WHERE t.id = api_topic_config.topic_id)
+      `);
+        db.exec("DROP TABLE api_topic_config");
+        db.exec("ALTER TABLE api_topic_config_next RENAME TO api_topic_config");
+      })();
+    } finally {
+      db.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? "ON" : "OFF"}`);
+    }
+  } else {
+    createCanonicalConfigTable();
+  }
+}
+registerStorageSchemaInitializer(initializeApiTopicConfigSchema, 40);
+function rowToConfig(r) {
+  const cfg = {};
+  if (r.model)
+    cfg.model = r.model;
+  if (r.effort)
+    cfg.effort = r.effort;
+  if (r.mcp) {
+    try {
+      const parsed = JSON.parse(r.mcp);
+      if (Array.isArray(parsed))
+        cfg.mcp = parsed;
+    } catch {}
+  }
+  if (r.agent_locked)
+    cfg.agentLocked = true;
+  if (r.model_locked)
+    cfg.modelLocked = true;
+  if (r.effort_locked)
+    cfg.effortLocked = true;
+  return cfg;
+}
+function getApiTopicConfig(topicId) {
+  const row = db.query("SELECT topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked FROM api_topic_config WHERE topic_id = ?").get(topicId);
+  if (!row)
+    return;
+  const config = rowToConfig(row);
+  return Object.keys(config).length > 0 ? config : undefined;
+}
+function setApiTopicConfig(topicId, config) {
+  db.query(`INSERT INTO api_topic_config
+       (topic_id, model, effort, mcp, agent_locked, model_locked, effort_locked)
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(topic_id) DO UPDATE SET
+       model = excluded.model,
+       effort = excluded.effort,
+       mcp = excluded.mcp,
+       agent_locked = excluded.agent_locked,
+       model_locked = excluded.model_locked,
+       effort_locked = excluded.effort_locked`).run(topicId, config.model ?? null, config.effort ?? null, config.mcp ? JSON.stringify(config.mcp) : null, config.agentLocked ? 1 : 0, config.modelLocked ? 1 : 0, config.effortLocked ? 1 : 0);
+}
+
+// ../../packages/core/src/storage/api-topics.ts
+var DEFAULT_AGENT_ROOM_AGENT = "maestro";
+function tableColumns2(table) {
+  const rows = db.query(`PRAGMA table_info(${table})`).all();
+  return new Set(rows.map((row) => row.name));
+}
+function initializeApiTopicsSchema() {
+  db.exec(`
+  CREATE TABLE IF NOT EXISTS api_topics (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    kind TEXT NOT NULL DEFAULT 'channel',
+    description TEXT,
+    agent TEXT,
+    default_model TEXT,
+    default_effort TEXT,
+    participants TEXT,
+    created_at TEXT NOT NULL,
+    last_message_at TEXT,
+    is_archived INTEGER NOT NULL DEFAULT 0,
+    ai_mention INTEGER NOT NULL DEFAULT 0,
+    ai_mode TEXT
+  )
+`);
+  const initialTopicColumns = tableColumns2("api_topics");
+  const legacyTopicSchema = !initialTopicColumns.has("response_policy");
+  const needsCanonicalTopicRebuild = legacyTopicSchema || !initialTopicColumns.has("agent");
+  if (legacyTopicSchema) {
+    try {
+      db.exec("ALTER TABLE api_topics RENAME COLUMN default_agent TO agent");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN ai_mention INTEGER NOT NULL DEFAULT 0");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN parent_topic_id TEXT");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN is_fork INTEGER NOT NULL DEFAULT 0");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN is_subagent INTEGER NOT NULL DEFAULT 0");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN session_id TEXT");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN kind TEXT NOT NULL DEFAULT 'channel'");
+    } catch {}
+    try {
+      db.exec("ALTER TABLE api_topics ADD COLUMN ai_mode TEXT");
+    } catch {}
+    db.exec(`
+  CREATE TABLE IF NOT EXISTS api_schema_migrations (
+    key TEXT PRIMARY KEY,
+    applied_at TEXT NOT NULL
+  )
+`);
+    const ALWAYS_RESPOND_MIGRATION = "api_topics_ai_invited_default_always_respond_20260623";
+    const alwaysRespondMigration = db.query("SELECT key FROM api_schema_migrations WHERE key = ?").get(ALWAYS_RESPOND_MIGRATION);
+    if (!alwaysRespondMigration) {
+      db.transaction(() => {
+        db.query("UPDATE api_topics SET ai_mention = 0 WHERE agent IS NOT NULL").run();
+        db.query("INSERT INTO api_schema_migrations (key, applied_at) VALUES (?, ?)").run(ALWAYS_RESPOND_MIGRATION, new Date().toISOString());
+      })();
+    }
+    const GENERAL_AGENT_KIND_MIGRATION = "api_topics_general_agent_kind_20260704";
+    const generalAgentKindMigration = db.query("SELECT key FROM api_schema_migrations WHERE key = ?").get(GENERAL_AGENT_KIND_MIGRATION);
+    if (!generalAgentKindMigration) {
+      db.transaction(() => {
+        db.query("UPDATE api_topics SET kind = 'agent', ai_mention = 0 WHERE id = ?").run(GENERAL_TOPIC_ID);
+        db.query("INSERT INTO api_schema_migrations (key, applied_at) VALUES (?, ?)").run(GENERAL_AGENT_KIND_MIGRATION, new Date().toISOString());
+      })();
+    }
+    const AI_MODE_MIGRATION = "api_topics_ai_mode_20260704";
+    const aiModeMigration = db.query("SELECT key FROM api_schema_migrations WHERE key = ?").get(AI_MODE_MIGRATION);
+    if (!aiModeMigration) {
+      db.transaction(() => {
+        db.query(`UPDATE api_topics
+       SET
+         kind = CASE
+           WHEN id = ? THEN 'agent'
+           WHEN kind = 'channel' AND agent IS NOT NULL AND ai_mention = 0 THEN 'agent'
+           ELSE kind
+         END,
+         ai_mode = CASE
+           WHEN id = ? THEN 'always'
+           WHEN agent IS NULL THEN 'off'
+           WHEN kind = 'agent' THEN 'always'
+           WHEN kind = 'channel' AND ai_mention != 0 THEN 'mention'
+           WHEN kind = 'channel' AND ai_mention = 0 THEN 'always'
+           WHEN ai_mention != 0 THEN 'mention'
+           ELSE 'always'
+         END`).run(GENERAL_TOPIC_ID, GENERAL_TOPIC_ID);
+        db.query("INSERT INTO api_schema_migrations (key, applied_at) VALUES (?, ?)").run(AI_MODE_MIGRATION, new Date().toISOString());
+      })();
+    }
+    const GENERAL_MANAGER_KIND_MIGRATION = "api_topics_general_manager_kind_20260704";
+    const generalManagerKindMigration = db.query("SELECT key FROM api_schema_migrations WHERE key = ?").get(GENERAL_MANAGER_KIND_MIGRATION);
+    if (!generalManagerKindMigration) {
+      db.transaction(() => {
+        db.query("UPDATE api_topics SET kind = 'manager', ai_mention = 0, ai_mode = 'always' WHERE id = ?").run(GENERAL_TOPIC_ID);
+        db.query("INSERT INTO api_schema_migrations (key, applied_at) VALUES (?, ?)").run(GENERAL_MANAGER_KIND_MIGRATION, new Date().toISOString());
+      })();
+    }
+  }
+  function createCanonicalTopicsTable(name) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS ${name} (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('channel','agent','manager')),
+      description TEXT,
+      agent TEXT CHECK (agent IS NULL OR agent IN ('maestro','claude','codex')),
+      base_model TEXT,
+      base_effort TEXT CHECK (base_effort IS NULL OR base_effort IN ('low','medium','high','xhigh','max')),
+      response_policy TEXT NOT NULL CHECK (response_policy IN ('off','mention','always')),
+      created_at TEXT NOT NULL,
+      last_message_at TEXT,
+      parent_topic_id TEXT,
+      is_fork INTEGER NOT NULL DEFAULT 0 CHECK (is_fork IN (0,1)),
+      is_subagent INTEGER NOT NULL DEFAULT 0 CHECK (is_subagent IN (0,1)),
+      visibility TEXT NOT NULL DEFAULT 'visible' CHECK (visibility IN ('visible','hidden')),
+      access_mode TEXT NOT NULL DEFAULT 'private' CHECK (access_mode IN ('private','shared')),
+      browser_profile TEXT NOT NULL DEFAULT 'default',
+      browser_profile_owner TEXT,
+      session_id TEXT,
+      CHECK (
+        (kind = 'channel' AND response_policy = 'off' AND agent IS NULL) OR
+        (kind = 'channel' AND response_policy = 'mention' AND agent IS NOT NULL) OR
+        (kind IN ('agent','manager') AND response_policy = 'always' AND agent IS NOT NULL)
+      )
+    )
+  `);
+  }
+  function createTopicMembersTable() {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS topic_members (
+      topic_id TEXT NOT NULL REFERENCES api_topics(id) ON DELETE CASCADE,
+      user_id TEXT NOT NULL,
+      role TEXT NOT NULL CHECK (role IN ('owner','member')),
+      PRIMARY KEY (topic_id, user_id)
+    )
+  `);
+    db.exec("CREATE INDEX IF NOT EXISTS idx_topic_members_user ON topic_members(user_id)");
+  }
+  if (needsCanonicalTopicRebuild) {
+    const legacyRows = db.query("SELECT * FROM api_topics").all();
+    const existingMemberRows = tableColumns2("topic_members").has("topic_id") ? db.query("SELECT topic_id, user_id, role FROM topic_members").all() : [];
+    const configColumns = tableColumns2("api_topic_config");
+    const legacyAgentOverrides = configColumns.has("agent") ? new Map(db.query("SELECT topic_id, agent FROM api_topic_config WHERE agent IS NOT NULL").all().map((row) => [row.topic_id, row.agent])) : new Map;
+    const previousForeignKeys = db.query("PRAGMA foreign_keys").get()?.foreign_keys;
+    db.exec("PRAGMA foreign_keys = OFF");
+    try {
+      db.transaction(() => {
+        createCanonicalTopicsTable("api_topics_next");
+        for (const row of legacyRows) {
+          const selectedAgent = legacyAgentOverrides.get(String(row.id)) ?? row.agent ?? row.runtime_agent ?? row.default_agent ?? undefined;
+          const normalized = normalizeTopicState({
+            id: String(row.id),
+            kind: normalizeTopicKind(row.kind),
+            agent: selectedAgent,
+            aiMode: normalizeAiMode(row.response_policy ?? row.ai_mode),
+            aiMention: Number(row.ai_mention ?? 0) !== 0
+          });
+          const legacyBaseModel = row.base_model ?? row.default_model;
+          const legacyBaseEffort = row.base_effort ?? row.default_effort;
+          db.query(`INSERT INTO api_topics_next
+             (id,title,kind,description,agent,base_model,base_effort,response_policy,
+              created_at,last_message_at,parent_topic_id,is_fork,is_subagent,visibility,access_mode,session_id)
+           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(String(row.id), String(row.title), normalized.kind, typeof row.description === "string" ? row.description : null, normalized.agent ?? null, typeof legacyBaseModel === "string" ? legacyBaseModel : null, typeof legacyBaseEffort === "string" ? legacyBaseEffort : null, normalized.aiMode, String(row.created_at), typeof row.last_message_at === "string" ? row.last_message_at : null, typeof row.parent_topic_id === "string" ? row.parent_topic_id : null, Number(row.is_fork ?? 0) !== 0 ? 1 : 0, Number(row.is_subagent ?? 0) !== 0 ? 1 : 0, row.visibility === "hidden" ? "hidden" : "visible", row.access_mode === "shared" ? "shared" : "private", typeof row.session_id === "string" ? row.session_id : null);
+        }
+        db.exec("DROP TABLE IF EXISTS topic_members");
+        db.exec("DROP TABLE api_topics");
+        db.exec("ALTER TABLE api_topics_next RENAME TO api_topics");
+        createTopicMembersTable();
+        if (existingMemberRows.length > 0) {
+          for (const member of existingMemberRows) {
+            db.query("INSERT OR REPLACE INTO topic_members (topic_id,user_id,role) VALUES (?,?,?)").run(member.topic_id, member.user_id, member.role === "owner" ? "owner" : "member");
+          }
+        } else {
+          for (const row of legacyRows) {
+            let participants = [];
+            try {
+              const parsed = JSON.parse(String(row.participants ?? "[]"));
+              if (Array.isArray(parsed))
+                participants = parsed;
+            } catch {
+              participants = [];
+            }
+            for (const participant of participants) {
+              if (!participant?.userId)
+                continue;
+              db.query("INSERT OR REPLACE INTO topic_members (topic_id,user_id,role) VALUES (?,?,?)").run(String(row.id), participant.userId, participant.role === "owner" ? "owner" : "member");
+            }
+          }
+        }
+      })();
+    } finally {
+      db.exec(`PRAGMA foreign_keys = ${previousForeignKeys ? "ON" : "OFF"}`);
+    }
+  } else {
+    createCanonicalTopicsTable("api_topics");
+    createTopicMembersTable();
+  }
+  if (!tableColumns2("api_topics").has("visibility")) {
+    db.exec("ALTER TABLE api_topics ADD COLUMN visibility TEXT NOT NULL DEFAULT 'visible'");
+  }
+  if (!tableColumns2("api_topics").has("access_mode")) {
+    db.exec("ALTER TABLE api_topics ADD COLUMN access_mode TEXT NOT NULL DEFAULT 'private'");
+  }
+  if (!tableColumns2("api_topics").has("browser_profile")) {
+    db.exec("ALTER TABLE api_topics ADD COLUMN browser_profile TEXT NOT NULL DEFAULT 'default'");
+  }
+  if (!tableColumns2("api_topics").has("browser_profile_owner")) {
+    db.exec("ALTER TABLE api_topics ADD COLUMN browser_profile_owner TEXT");
+  }
+  db.exec(`
+  UPDATE api_topics
+  SET browser_profile_owner = (
+    SELECT m.user_id FROM topic_members m
+    WHERE m.topic_id = api_topics.id AND m.role = 'owner'
+    ORDER BY m.rowid
+    LIMIT 1
+  )
+  WHERE browser_profile_owner IS NULL
+`);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_api_topics_last_message ON api_topics(last_message_at DESC)");
+}
+registerStorageSchemaInitializer(initializeApiTopicsSchema, 20);
+function getTopicParticipants(topicId) {
+  return db.query("SELECT user_id, role FROM topic_members WHERE topic_id = ? ORDER BY rowid").all(topicId).map((row) => ({ userId: row.user_id, role: row.role }));
+}
+function rowToDto(r, participants = getTopicParticipants(r.id)) {
+  const normalized = normalizeTopicState({
+    id: r.id,
+    kind: normalizeTopicKind(r.kind),
+    agent: r.agent ?? undefined,
+    aiMode: normalizeAiMode(r.response_policy)
+  });
+  return {
+    id: r.id,
+    title: r.title,
+    kind: normalized.kind,
+    description: r.description ?? undefined,
+    agent: normalized.agent,
+    defaultModel: r.base_model ?? "deepseek-pro",
+    defaultEffort: r.base_effort ?? undefined,
+    aiMode: normalized.aiMode,
+    aiMention: aiMentionFromMode(normalized.aiMode),
+    participants,
+    createdAt: r.created_at,
+    lastMessageAt: r.last_message_at ?? new Date().toISOString(),
+    parentTopicId: r.parent_topic_id ?? undefined,
+    isFork: r.is_fork !== 0,
+    ...r.is_subagent !== 0 ? { isSubagent: true } : {},
+    visibility: normalizeTopicVisibility(r.visibility),
+    accessMode: normalizeTopicAccessMode(r.access_mode)
+  };
+}
+function normalizeTopicAccessMode(value) {
+  return value === "shared" ? "shared" : "private";
+}
+function normalizeTopicVisibility(value) {
+  return value === "hidden" ? "hidden" : "visible";
+}
+function normalizeTopicKind(value) {
+  return value === "channel" || value === "agent" || value === "manager" ? value : null;
+}
+function normalizeAiMode(value) {
+  return value === "off" || value === "mention" || value === "always" ? value : null;
+}
+function aiMentionFromMode(mode) {
+  return mode === "mention";
+}
+function normalizeTopicState(input) {
+  if (input.kind === "manager" || input.id === GENERAL_TOPIC_ID) {
+    return {
+      kind: "manager",
+      aiMode: "always",
+      agent: input.agent ?? DEFAULT_AGENT_ROOM_AGENT
+    };
+  }
+  const requestedKind = input.kind;
+  const kind = requestedKind ?? (input.aiMode === "always" ? "agent" : input.aiMode === "mention" || input.aiMode === "off" ? "channel" : input.agent && input.aiMention !== true ? "agent" : "channel");
+  if (kind === "agent") {
+    return {
+      kind: "agent",
+      aiMode: "always",
+      agent: input.agent ?? DEFAULT_AGENT_ROOM_AGENT
+    };
+  }
+  const agent = input.aiMode === "off" ? undefined : input.agent ?? undefined;
+  return {
+    kind: "channel",
+    aiMode: agent ? "mention" : "off",
+    agent
+  };
+}
+function upsertTopic(t) {
+  const normalized = normalizeTopicState({
+    id: t.id,
+    kind: normalizeTopicKind(t.kind),
+    agent: t.agent ?? undefined,
+    aiMode: normalizeAiMode(t.aiMode),
+    aiMention: t.aiMention
+  });
+  db.transaction(() => {
+    db.query(`INSERT INTO api_topics
+       (id,title,kind,description,agent,base_model,base_effort,response_policy,
+        created_at,last_message_at,parent_topic_id,is_fork,is_subagent,visibility,access_mode)
+     VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+     ON CONFLICT(id) DO UPDATE SET
+       title = excluded.title,
+       kind = excluded.kind,
+       description = excluded.description,
+       agent = excluded.agent,
+       base_model = excluded.base_model,
+       base_effort = excluded.base_effort,
+       response_policy = excluded.response_policy,
+       created_at = excluded.created_at,
+       last_message_at = excluded.last_message_at,
+       parent_topic_id = excluded.parent_topic_id,
+       is_fork = excluded.is_fork,
+       is_subagent = excluded.is_subagent,
+       visibility = excluded.visibility,
+       access_mode = excluded.access_mode`).run(t.id, t.title, normalized.kind, t.description ?? null, normalized.agent ?? null, t.defaultModel ?? null, t.defaultEffort ?? null, normalized.aiMode, t.createdAt, t.lastMessageAt ?? null, t.parentTopicId ?? null, t.isFork ? 1 : 0, t.isSubagent ? 1 : 0, normalizeTopicVisibility(t.visibility), normalizeTopicAccessMode(t.accessMode));
+    db.query("DELETE FROM topic_members WHERE topic_id = ?").run(t.id);
+    for (const participant of t.participants) {
+      db.query("INSERT INTO topic_members (topic_id,user_id,role) VALUES (?,?,?)").run(t.id, participant.userId, participant.role);
+    }
+    const initialBrowserProfileOwner = t.participants.find((participant) => participant.role === "owner")?.userId;
+    if (initialBrowserProfileOwner) {
+      db.query(`UPDATE api_topics
+         SET browser_profile_owner = COALESCE(browser_profile_owner, ?)
+         WHERE id = ?`).run(initialBrowserProfileOwner, t.id);
+    }
+  })();
+}
+function getTopic(id) {
+  const r = db.query("SELECT * FROM api_topics WHERE id = ?").get(id);
+  return r ? rowToDto(r) : null;
+}
+function getManagerTopicForUser(userId) {
+  const row = db.query(`SELECT t.* FROM api_topics t
+       JOIN topic_members m ON m.topic_id = t.id
+       WHERE t.kind = 'manager'
+         AND t.id != ?
+         AND m.user_id = ?
+         AND m.role = 'owner'
+       ORDER BY t.created_at ASC
+       LIMIT 1`).get(GENERAL_TOPIC_ID, userId);
+  return row ? rowToDto(row) : null;
+}
+function getTopicMemoryOrigin(id) {
+  let current2 = getTopic(id);
+  if (!current2)
+    return null;
+  const seen = new Set([current2.id]);
+  while (current2.parentTopicId && !seen.has(current2.parentTopicId)) {
+    const parent = getTopic(current2.parentTopicId);
+    if (!parent)
+      break;
+    current2 = parent;
+    seen.add(current2.id);
+  }
+  return current2;
+}
+
+// ../../packages/core/src/topics/personal-general.ts
+var LEGACY_PERSONAL_GENERAL_DESCRIPTION = "\uB098\uB9CC\uC758 \uAC1C\uC778 \uACF5\uAC04\uC774\uC5D0\uC694. \uB300\uD654\uC640 AI \uC791\uC5C5\uC740 \uB2E4\uB978 \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uACF5\uAC1C\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+var PERSONAL_GENERAL_DESCRIPTION = "Your private General. Messages and membership are visible only to you. Workspace memory, wiki, and skills are shared with your workspace.";
+function ensurePersonalGeneral(userId) {
+  const existing = getManagerTopicForUser(userId);
+  if (existing) {
+    if (existing.description === LEGACY_PERSONAL_GENERAL_DESCRIPTION) {
+      existing.description = PERSONAL_GENERAL_DESCRIPTION;
+      upsertTopic(existing);
+    }
+    if (!getApiTopicConfig(existing.id)) {
+      setApiTopicConfig(existing.id, { model: "deepseek-pro", modelLocked: true });
+    }
+    return existing;
+  }
+  const now = new Date().toISOString();
+  const registry = getRegistry("maestro");
+  const topic = {
+    id: randomUUID3(),
+    title: "General",
+    description: PERSONAL_GENERAL_DESCRIPTION,
+    kind: "manager",
+    agent: "maestro",
+    defaultModel: resolveDefaultModel("maestro", registry.defaultModel),
+    defaultEffort: registry.defaultEffort ?? "medium",
+    aiMode: "always",
+    aiMention: false,
+    participants: [{ userId, role: "owner" }],
+    createdAt: now,
+    lastMessageAt: now
+  };
+  upsertTopic(topic);
+  setApiTopicConfig(topic.id, { model: "deepseek-pro", modelLocked: true });
+  return topic;
+}
+
+// ../../packages/core/src/agents/archiver.ts
+var MAX_BRIEF_ENTRIES = 8;
+var MIN_ARCHIVE_MESSAGES = 4;
+var MAX_SESSION_STEPS = 20;
+var activeArchiverSessions = new Map;
+function boundedSessionText(value) {
+  return value.replace(/\s+/g, " ").trim().slice(0, 160);
+}
+function updateArchiverSession(id, status, step) {
+  const session = activeArchiverSessions.get(id);
+  if (!session)
+    return;
+  session.status = boundedSessionText(status) || session.status;
+  if (step) {
+    const text = boundedSessionText(step);
+    if (text && session.steps.at(-1) !== text) {
+      session.steps.push(text);
+      if (session.steps.length > MAX_SESSION_STEPS)
+        session.steps.shift();
+    }
+  }
+}
+var _archiverDef = null;
+function getArchiverDef() {
+  if (!_archiverDef)
+    _archiverDef = loadAgentPrompt("wiki-archiver.md");
+  return _archiverDef;
+}
+function runArchiverTurn(params) {
+  const { userId, topicId, topicTitle, archivePath, messageCount, mode = "deleted-topic" } = params;
+  if (mode !== "active-topic" && messageCount < MIN_ARCHIVE_MESSAGES) {
+    logger.info({ userId, topicTitle, messageCount, min: MIN_ARCHIVE_MESSAGES }, "archiver: skipped \u2014 too few messages to distil");
+    return false;
+  }
+  let archiverDef;
+  try {
+    archiverDef = getArchiverDef();
+  } catch (err) {
+    logger.warn({ err }, "archiver: failed to load wiki-archiver.md \u2014 skipping");
+    return false;
+  }
+  const wikiDir = getSharedWikiDir();
+  const safeTopic = sanitizeTopicName(topicTitle, true);
+  const agent = params.agent ?? "claude";
+  const model = params.model;
+  const prompt = mode === "active-topic" ? [
+    `\uC138\uC158 "${topicTitle}" \uC758 \uCD5C\uADFC idle \uB300\uD654 snapshot\uC785\uB2C8\uB2E4. \uC544\uB798 \uC544\uCE74\uC774\uBE0C\uC5D0\uC11C \uAE30\uC5B5\uC744 \uCD94\uCD9C\uD574 \uC774 \uD1A0\uD53D \uC704\uD0A4\uC5D0 \uC800\uC7A5\uD574\uC918.`,
+    `archive_path: ${archivePath}`,
+    `wiki_dir: ${wikiDir}`
+  ].join(`
+`) : [
+    `\uC138\uC158 "${topicTitle}" \uC774(\uAC00) \uC0AD\uC81C\uB418\uC5C8\uC2B5\uB2C8\uB2E4. \uC544\uB798 \uC544\uCE74\uC774\uBE0C\uC5D0\uC11C \uAE30\uC5B5\uC744 \uCD94\uCD9C\uD574 \uC704\uD0A4\uC5D0 \uC800\uC7A5\uD574\uC918.`,
+    `archive_path: ${archivePath}`,
+    `wiki_dir: ${wikiDir}`,
+    "",
+    "#General\uC5D0 \uD45C\uC2DC\uB420 \uC9E7\uC740 \uD55C\uAD6D\uC5B4 \uC644\uB8CC \uBA54\uC2DC\uC9C0\uB85C \uCD5C\uC885 \uC751\uB2F5\uD574\uC918. " + "\uB3C4\uAD6C \uD638\uCD9C \uB85C\uADF8\uB098 \uC6D0\uBB38 \uC804\uBB38\uC740 \uC4F0\uC9C0 \uB9D0\uACE0, \uC800\uC7A5\uD55C \uC694\uC57D/\uBE0C\uB9AC\uD504/\uBB38\uC11C\uB9CC \uAC04\uB2E8\uD788 \uB9D0\uD574\uC918."
+  ].join(`
+`);
+  const abortController = new AbortController;
+  const events = runAgent({
+    agent,
+    prompt,
+    cwd: WORKSPACE_DIR,
+    systemPrompt: archiverDef.prompt,
+    userId,
+    session: `__archiver_${safeTopic}`,
+    sessionType: "forum",
+    topicId,
+    abortController,
+    model,
+    mcpEnabled: ["wiki"],
+    silent: true
+  });
+  const activeSessionId = `memory:${randomUUID4()}`;
+  activeArchiverSessions.set(activeSessionId, {
+    id: activeSessionId,
+    kind: "memory",
+    title: `Archive ${topicTitle}`,
+    topicId,
+    userId,
+    startedAt: new Date().toISOString(),
+    status: "Starting",
+    active: true,
+    agent,
+    model: model ?? archiverDef.model,
+    prompt,
+    promptTitle: "Prompt",
+    steps: ["Preparing archived conversation"]
+  });
+  logger.info({ userId, topicTitle, archivePath, agent, model }, "archiver: starting background turn");
+  const startMs = Date.now();
+  (async () => {
+    let ok = false;
+    let sawDelta = false;
+    let accumulatedText = "";
+    let resultText = "";
+    let usage;
+    try {
+      for await (const event of events) {
+        switch (event.type) {
+          case "tool_use":
+            updateArchiverSession(activeSessionId, `Running ${event.name}`, `Tool: ${event.name}`);
+            break;
+          case "tool_progress":
+            {
+              const progress = `${event.toolName === "thinking" ? "Thinking" : event.toolName} \xB7 ${Math.max(0, Math.floor(event.elapsed))}s`;
+              updateArchiverSession(activeSessionId, progress, progress);
+            }
+            break;
+          case "reasoning":
+            updateArchiverSession(activeSessionId, "Reasoning", `Reasoning: ${event.content}`);
+            break;
+          case "tool_use_summary":
+            updateArchiverSession(activeSessionId, event.summary, event.summary);
+            break;
+          case "status":
+            updateArchiverSession(activeSessionId, event.content, event.content);
+            break;
+          case "tool_result":
+            updateArchiverSession(activeSessionId, "Processing tool result");
+            break;
+          case "text_delta":
+            sawDelta = true;
+            accumulatedText += event.content;
+            break;
+          case "text":
+            if (!sawDelta)
+              accumulatedText += event.content;
+            break;
+          case "result":
+            updateArchiverSession(activeSessionId, "Finalizing memory");
+            resultText = event.content;
+            usage = event.usage ? { input: event.usage.inputTokens, output: event.usage.outputTokens } : undefined;
+            break;
+          default:
+            break;
+        }
+      }
+      ok = true;
+      logger.info({ userId, topicTitle }, "archiver: background turn completed");
+    } catch (err) {
+      updateArchiverSession(activeSessionId, "Failed", "Memory archive failed");
+      logger.warn({ err, userId, topicTitle }, "archiver: background turn failed");
+    } finally {
+      activeArchiverSessions.delete(activeSessionId);
+      try {
+        params.onSettled?.(ok);
+      } catch (err) {
+        logger.warn({ err, userId, topicTitle }, "archiver: settlement callback failed");
+      }
+    }
+    if (mode === "deleted-topic") {
+      const text = (accumulatedText.trim() ? accumulatedText : resultText).trimEnd();
+      finalizeGeneralMemory(userId, topicTitle, messageCount, startMs, ok, topicId, ok && text ? { text, agent, model, usage } : undefined);
+    }
+  })();
+  return true;
+}
+function distillOneLine(summaryMd) {
+  const body = summaryMd.replace(/^---[\s\S]*?---\n?/, "");
+  for (const raw of body.split(`
+`)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    return line.replace(/^[-*]\s*/, "").slice(0, 160);
+  }
+  return "";
+}
+function findSummaryFile(topicTitle, date, sinceMs, topicId) {
+  const dir = join15(getSharedWikiDir(), "summaries");
+  if (!existsSync13(dir))
+    return null;
+  const predicted = join15(dir, wikiSummaryFilename(date, topicTitle, topicId));
+  if (existsSync13(predicted))
+    return predicted;
+  let best = null;
+  for (const f of readdirSync2(dir)) {
+    if (!f.endsWith(".md"))
+      continue;
+    const p = join15(dir, f);
+    try {
+      const m = statSync4(p).mtimeMs;
+      if (m >= sinceMs && (!best || m > best.mtime))
+        best = { path: p, mtime: m };
+    } catch {}
+  }
+  return best?.path ?? null;
+}
+function finalizeGeneralMemory(userId, topicTitle, messageCount, startMs, ok, topicId, generalReply) {
+  const generalTopicId = ensurePersonalGeneral(userId).id;
+  const date = new Date().toISOString().slice(0, 10);
+  try {
+    const summaryPath = ok ? findSummaryFile(topicTitle, date, startMs, topicId) : null;
+    const summaryMd = summaryPath ? readFileSync10(summaryPath, "utf-8") : "";
+    const oneLine = summaryMd && distillOneLine(summaryMd) || `${messageCount}\uAC1C \uBA54\uC2DC\uC9C0 \uC544\uCE74\uC774\uBE0C`;
+    const prev = getTopicBrief(generalTopicId);
+    const prevEntries = (prev?.briefMd ?? "").split(`
+`).map((l) => l.trim()).filter((l) => l.startsWith("- "));
+    const newEntry = `- **${topicTitle}** (${date}): ${oneLine}`;
+    const rolled = [
+      newEntry,
+      ...prevEntries.filter((l) => !l.startsWith(`- **${topicTitle}** `))
+    ].slice(0, MAX_BRIEF_ENTRIES);
+    const briefMd = `# \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uBA54\uBAA8\uB9AC \uD5C8\uBE0C
+
+\uC0AD\uC81C\uB41C \uD1A0\uD53D\uC5D0\uC11C \uCD94\uCD9C\uD55C \uCD5C\uADFC \uAE30\uC5B5 \uB2E4\uC774\uC81C\uC2A4\uD2B8\uC785\uB2C8\uB2E4. \uC790\uC138\uD55C \uB0B4\uC6A9\uC740 \`wiki_query\`\uB85C \uC870\uD68C\uD558\uC138\uC694.
+
+## \uCD5C\uADFC \uC544\uCE74\uC774\uBE0C
+${rolled.join(`
+`)}`;
+    setTopicBrief(generalTopicId, {
+      briefMd,
+      ...summaryMd ? { latestSummaryMd: summaryMd, summaryDate: date } : {}
+    });
+    logger.info({ topicTitle, summaryPath, entries: rolled.length }, "archiver: updated #General memory hub brief");
+  } catch (err) {
+    logger.warn({ err, topicTitle }, "archiver: failed to update #General brief");
+  }
+  try {
+    const replyText = generalReply?.text.trim();
+    const text = replyText || (ok ? `\uD83D\uDDC2 "${topicTitle}" \uD1A0\uD53D\uC774 \uC0AD\uC81C\uB418\uC5B4 #General \uBA54\uBAA8\uB9AC\uC5D0 \uC544\uCE74\uC774\uBE0C\uB410\uC5B4\uC694.` : `\uD83D\uDDC2 "${topicTitle}" \uD1A0\uD53D\uC744 \uC544\uCE74\uC774\uBE0C\uD588\uC5B4\uC694 (\uC694\uC57D \uCD94\uCD9C\uC740 \uC2E4\uD328 \u2014 \uC6D0\uBCF8\uC740 wiki/archive\uC5D0 \uBCF4\uC874).`);
+    const replyMeta = generalReply && replyText ? {
+      authorId: "ai",
+      agentType: generalReply.agent,
+      model: generalReply.model,
+      usage: generalReply.usage
+    } : { authorId: "system" };
+    const msg = {
+      id: randomUUID4(),
+      topicId: generalTopicId,
+      text,
+      ...replyMeta,
+      createdAt: new Date().toISOString()
+    };
+    appendApiMessage(msg);
+    WsHub.get().broadcastMessage(generalTopicId, msg);
+  } catch (err) {
+    logger.warn({ err, topicTitle }, "archiver: failed to post #General notification");
+  }
+}
+
+// ../../packages/core/src/storage/runtime-leases.ts
+import { randomUUID as randomUUID5 } from "crypto";
+
+// ../../packages/core/src/storage/runtime-topic-state.ts
+var TOPIC_MAINTENANCE_STALE_MS = 30000;
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_topic_state (
+    topic_id TEXT PRIMARY KEY,
+    epoch INTEGER NOT NULL DEFAULT 0,
+    maintenance INTEGER NOT NULL DEFAULT 0 CHECK (maintenance IN (0, 1)),
+    maintenance_owner TEXT,
+    heartbeat_at INTEGER
+  )
+`);
+
+// ../../packages/core/src/storage/runtime-leases.ts
+var RUNTIME_INSTANCE_ID = `${process.pid}-${randomUUID5()}`;
+var TURN_LEASE_STALE_MS = 1e4;
+db.exec(`
+  CREATE TABLE IF NOT EXISTS runtime_turn_leases (
+    topic_id TEXT PRIMARY KEY,
+    query_id TEXT NOT NULL UNIQUE,
+    owner_id TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    started_at INTEGER NOT NULL,
+    heartbeat_at INTEGER NOT NULL,
+    abort_requested INTEGER NOT NULL DEFAULT 0 CHECK (abort_requested IN (0, 1)),
+    abort_reason TEXT CHECK (abort_reason IS NULL OR abort_reason IN ('internal', 'external'))
+  )
+`);
+db.exec("CREATE INDEX IF NOT EXISTS idx_runtime_turn_leases_heartbeat ON runtime_turn_leases(heartbeat_at)");
+function rowToLease(row) {
+  const abortReason = row.abort_reason === "internal" || row.abort_reason === "external" ? row.abort_reason : undefined;
+  return {
+    topicId: row.topic_id,
+    queryId: row.query_id,
+    ownerId: row.owner_id,
+    origin: row.origin,
+    startedAt: Number(row.started_at),
+    heartbeatAt: Number(row.heartbeat_at),
+    abortRequested: row.abort_requested !== 0,
+    abortReason
+  };
+}
+function getRuntimeTurnLease(topicId, now = Date.now()) {
+  const row = db.query("SELECT * FROM runtime_turn_leases WHERE topic_id = ?").get(topicId);
+  if (!row)
+    return null;
+  const lease = rowToLease(row);
+  return now - lease.heartbeatAt <= TURN_LEASE_STALE_MS ? lease : null;
+}
+function listRuntimeTurnLeases(now = Date.now()) {
+  return db.query("SELECT * FROM runtime_turn_leases ORDER BY started_at ASC").all().map(rowToLease).filter((lease) => now - lease.heartbeatAt <= TURN_LEASE_STALE_MS);
+}
+function claimRuntimeTurnLease(input, now = Date.now()) {
+  const ownerId = input.ownerId ?? RUNTIME_INSTANCE_ID;
+  const result = db.query(`INSERT INTO runtime_turn_leases
+         (topic_id, query_id, owner_id, origin, started_at, heartbeat_at, abort_requested, abort_reason)
+       SELECT ?, ?, ?, ?, ?, ?, 0, NULL
+       WHERE NOT EXISTS (
+         SELECT 1 FROM runtime_topic_state
+         WHERE topic_id = ? AND maintenance = 1 AND heartbeat_at >= ?
+       )
+       ON CONFLICT(topic_id) DO UPDATE SET
+         query_id = excluded.query_id,
+         owner_id = excluded.owner_id,
+         origin = excluded.origin,
+         started_at = excluded.started_at,
+         heartbeat_at = excluded.heartbeat_at,
+         abort_requested = 0,
+         abort_reason = NULL
+       WHERE (runtime_turn_leases.owner_id = excluded.owner_id
+          OR runtime_turn_leases.heartbeat_at < ?)
+         AND NOT EXISTS (
+           SELECT 1 FROM runtime_topic_state
+           WHERE topic_id = excluded.topic_id AND maintenance = 1 AND heartbeat_at >= ?
+         )`).run(input.topicId, input.queryId, ownerId, input.origin, now, now, input.topicId, now - TOPIC_MAINTENANCE_STALE_MS, now - TURN_LEASE_STALE_MS, now - TOPIC_MAINTENANCE_STALE_MS);
+  return Number(result.changes ?? 0) > 0;
+}
+function heartbeatRuntimeTurnLease(topicId, queryId, ownerId = RUNTIME_INSTANCE_ID, now = Date.now()) {
+  const updated = db.query(`UPDATE runtime_turn_leases
+       SET heartbeat_at = ?
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`).run(now, topicId, queryId, ownerId);
+  if (Number(updated.changes ?? 0) === 0)
+    return { owned: false, abortRequested: false };
+  const row = db.query(`SELECT abort_requested, abort_reason
+       FROM runtime_turn_leases
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`).get(topicId, queryId, ownerId);
+  const abortReason = row?.abort_reason === "internal" || row?.abort_reason === "external" ? row.abort_reason : undefined;
+  return {
+    owned: Boolean(row),
+    abortRequested: row?.abort_requested !== 0,
+    abortReason
+  };
+}
+function requestRuntimeTurnAbort(topicId, reason) {
+  const result = db.query(`UPDATE runtime_turn_leases
+       SET abort_requested = 1,
+           abort_reason = CASE
+             WHEN abort_reason = 'external' THEN abort_reason
+             ELSE ?
+           END
+       WHERE topic_id = ? AND heartbeat_at >= ?`).run(reason, topicId, Date.now() - TURN_LEASE_STALE_MS);
+  return Number(result.changes ?? 0) > 0;
+}
+function releaseRuntimeTurnLease(topicId, queryId, ownerId = RUNTIME_INSTANCE_ID) {
+  const result = db.query(`DELETE FROM runtime_turn_leases
+       WHERE topic_id = ? AND query_id = ? AND owner_id = ?`).run(topicId, queryId, ownerId);
+  return Number(result.changes ?? 0) > 0;
+}
+
+// ../../packages/core/src/query/room-query-registry.ts
+var ISOLATED_TURN_ROOM_MARKER = "::isolated-turn::";
+function isIsolatedTurnRoomId(roomId) {
+  return roomId.includes(ISOLATED_TURN_ROOM_MARKER);
+}
+function isUserOrigin(origin) {
+  return !origin || origin === "user";
+}
+function createRoomQueryRegistry(host) {
+  const activeByRoom = new Map;
+  const leaseMonitors = new Map;
+  const now = host.now ?? Date.now;
+  const heartbeatMs = host.heartbeatMs ?? 1000;
+  function get(roomId) {
+    return activeByRoom.get(roomId);
+  }
+  function listRunningTopicQueries() {
+    const queries = new Map([...activeByRoom.entries()].filter(([roomId]) => !isIsolatedTurnRoomId(roomId)).map(([roomId, control]) => [roomId, control.queryId]));
+    for (const lease of host.listLeases()) {
+      if (isIsolatedTurnRoomId(lease.topicId))
+        continue;
+      if (!queries.has(lease.topicId))
+        queries.set(lease.topicId, lease.queryId);
+    }
+    return queries;
+  }
+  function listRunningTopicIds() {
+    return new Set(listRunningTopicQueries().keys());
+  }
+  function isTopicRunning(topicId) {
+    return activeByRoom.has(topicId) || host.getLease(topicId) !== null;
+  }
+  function status(topicId, queryId) {
+    if (activeByRoom.get(topicId)?.queryId === queryId)
+      return "running";
+    return host.getLease(topicId)?.queryId === queryId ? "running" : "not_found";
+  }
+  function set(control) {
+    const roomId = control.roomId ?? control.topicId;
+    control.startedAt ??= now();
+    if (!host.claimLease({ topicId: roomId, queryId: control.queryId, origin: control.origin })) {
+      return false;
+    }
+    const previousMonitor = leaseMonitors.get(roomId);
+    if (previousMonitor)
+      clearInterval(previousMonitor);
+    activeByRoom.set(roomId, control);
+    const monitor = setInterval(() => {
+      const current2 = activeByRoom.get(roomId);
+      if (!current2 || current2.queryId !== control.queryId) {
+        clearInterval(monitor);
+        if (leaseMonitors.get(roomId) === monitor)
+          leaseMonitors.delete(roomId);
+        return;
+      }
+      const heartbeat = host.heartbeatLease(roomId, control.queryId);
+      if (!heartbeat.owned) {
+        control.abortReason = host.externalAbortReason;
+        control.abortController.abort();
+        return;
+      }
+      if (heartbeat.abortRequested && !control.abortController.signal.aborted) {
+        control.abortReason = heartbeat.abortReason === "internal" ? host.internalAbortReason : host.externalAbortReason;
+        control.abortController.abort();
+      }
+    }, heartbeatMs);
+    monitor.unref?.();
+    leaseMonitors.set(roomId, monitor);
+    return true;
+  }
+  function clear(roomId, queryId) {
+    const current2 = activeByRoom.get(roomId);
+    if (current2?.queryId === queryId) {
+      activeByRoom.delete(roomId);
+      const monitor = leaseMonitors.get(roomId);
+      if (monitor)
+        clearInterval(monitor);
+      leaseMonitors.delete(roomId);
+    }
+    host.releaseLease(roomId, queryId);
+  }
+  function abort(roomId, reason = host.externalAbortReason) {
+    const running = activeByRoom.get(roomId);
+    const wireReason = reason === host.internalAbortReason ? "internal" : "external";
+    if (running) {
+      running.abortReason = reason;
+      running.abortController.abort();
+      host.requestAbort(roomId, wireReason);
+      return true;
+    }
+    return host.requestAbort(roomId, wireReason);
+  }
+  function abortAll(reason = host.externalAbortReason) {
+    let aborted = 0;
+    for (const running of activeByRoom.values()) {
+      running.abortReason = reason;
+      if (!running.abortController.signal.aborted) {
+        running.abortController.abort();
+        aborted++;
+      }
+    }
+    return aborted;
+  }
+  function decide(topicId, incomingOrigin) {
+    const running = activeByRoom.get(topicId);
+    if (!running) {
+      const remote = host.getLease(topicId);
+      if (!remote || remote.ownerId === host.instanceId)
+        return { action: "proceed" };
+      return isUserOrigin(incomingOrigin) ? { action: "remote-abort-wait", running: remote } : { action: "remote-defer", running: remote };
+    }
+    if (!isUserOrigin(incomingOrigin))
+      return { action: "defer" };
+    return { action: "abort-replace", running };
+  }
+  return {
+    get,
+    listRunningTopicQueries,
+    listRunningTopicIds,
+    isTopicRunning,
+    status,
+    set,
+    clear,
+    abort,
+    abortAll,
+    decide
+  };
+}
+
+// ../../packages/core/src/query/active-rooms.ts
+var roomQueryRegistry = createRoomQueryRegistry({
+  instanceId: RUNTIME_INSTANCE_ID,
+  internalAbortReason: "internal" /* Internal */,
+  externalAbortReason: "external" /* External */,
+  listLeases: listRuntimeTurnLeases,
+  getLease: getRuntimeTurnLease,
+  claimLease: claimRuntimeTurnLease,
+  heartbeatLease: heartbeatRuntimeTurnLease,
+  releaseLease: releaseRuntimeTurnLease,
+  requestAbort: requestRuntimeTurnAbort
+});
+function getRoomQuery(topicId) {
+  return roomQueryRegistry.get(topicId);
+}
+class InterSessionQueue {
+  queue = new Map;
+  compactOrDelete(topicId, bucket) {
+    if (bucket.head >= bucket.items.length) {
+      this.queue.delete(topicId);
+      return;
+    }
+    if (bucket.head >= 64 && bucket.head * 2 >= bucket.items.length) {
+      bucket.items = bucket.items.slice(bucket.head);
+      bucket.head = 0;
+    }
+  }
+  enqueue(topicId, inject) {
+    if (!inject.requestId) {
+      logger.error({ topicId, origin: inject.origin }, "BUG: session inject reached enqueue without requestId \u2014 DROPPING inject");
+      return false;
+    }
+    let bucket = this.queue.get(topicId);
+    if (!bucket) {
+      bucket = { items: [], head: 0, requestIds: new Set };
+      this.queue.set(topicId, bucket);
+    }
+    if (bucket.requestIds.has(inject.requestId)) {
+      logger.info({ topicId, requestId: inject.requestId, origin: inject.origin }, "session inject deduped (existing entry with same requestId)");
+      return false;
+    }
+    bucket.items.push(inject);
+    bucket.requestIds.add(inject.requestId);
+    logger.info({ topicId, origin: inject.origin, requestId: inject.requestId, depth: inject.depth }, "session inject enqueued");
+    return true;
+  }
+  hasRequest(topicId, requestId) {
+    return this.queue.get(topicId)?.requestIds.has(requestId) ?? false;
+  }
+  dequeueNext(topicId) {
+    const bucket = this.queue.get(topicId);
+    if (!bucket || bucket.head >= bucket.items.length)
+      return;
+    const next = bucket.items[bucket.head++];
+    if (next.requestId)
+      bucket.requestIds.delete(next.requestId);
+    this.compactOrDelete(topicId, bucket);
+    return next;
+  }
+  dequeueAll(topicId) {
+    const bucket = this.queue.get(topicId);
+    if (!bucket || bucket.head >= bucket.items.length)
+      return;
+    const base = bucket.items[bucket.head];
+    const isAskReplyInject = (e) => !e.silent && Boolean(e.askReplySources?.length);
+    const baseIsAskReplyInject = isAskReplyInject(base);
+    const mergeable = (e) => (baseIsAskReplyInject ? isAskReplyInject(e) : !isAskReplyInject(e) && e.origin === base.origin && (e.silent ?? false) === (base.silent ?? false)) && e.onDispatched !== undefined === (base.onDispatched !== undefined) && (e.agentOverride ?? null) === (base.agentOverride ?? null) && (e.modelOverride ?? null) === (base.modelOverride ?? null) && (e.effortOverride ?? null) === (base.effortOverride ?? null) && (e.runtimeEpoch ?? 0) === (base.runtimeEpoch ?? 0) && (e.sessionId ?? null) === (base.sessionId ?? null) && (e.forkHandle?.forkId ?? null) === (base.forkHandle?.forkId ?? null) && (e.prepareSession ?? null) === (base.prepareSession ?? null) && (e.cwd ?? null) === (base.cwd ?? null) && (e.sessionName ?? null) === (base.sessionName ?? null) && (e.sessionType ?? null) === (base.sessionType ?? null) && (e.onSessionId ?? null) === (base.onSessionId ?? null) && (e.onSessionReset ?? null) === (base.onSessionReset ?? null) && (e.bridgeSessionFromHistory ?? false) === (base.bridgeSessionFromHistory ?? false) && (e.onSettled ?? null) === (base.onSettled ?? null);
+    let end = bucket.head + 1;
+    while (end < bucket.items.length && mergeable(bucket.items[end]))
+      end++;
+    const batch = bucket.items.slice(bucket.head, end);
+    bucket.head = end;
+    for (const entry of batch) {
+      if (entry.requestId)
+        bucket.requestIds.delete(entry.requestId);
+    }
+    this.compactOrDelete(topicId, bucket);
+    if (batch.length === 1)
+      return batch[0];
+    const callbacks = batch.map((e) => e.onDispatched).filter((cb) => !!cb);
+    const askReplySources = batch.flatMap((e) => {
+      if (e.askReplySources?.length)
+        return e.askReplySources;
+      if (!e.requestId || !e.origin)
+        return [];
+      return [{ from: e.origin, requestId: e.requestId, contextId: e.contextId }];
+    });
+    const depths = batch.map((e) => e.depth).filter((depth) => typeof depth === "number");
+    return {
+      ...base,
+      prompt: batch.map((e) => e.prompt).join(`
+
+`),
+      origin: baseIsAskReplyInject ? [...new Set(batch.map((e) => e.origin).filter(Boolean))].join(", ") : base.origin,
+      depth: depths.length ? Math.min(...depths) : base.depth,
+      requestId: `merged-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      contextId: batch.every((e) => e.contextId === base.contextId) ? base.contextId : undefined,
+      askReplySources,
+      onDispatched: callbacks.length ? (queryId) => {
+        callbacks.forEach((cb) => {
+          cb(queryId);
+        });
+      } : undefined
+    };
+  }
+  keysForRoom() {
+    return Array.from(this.queue.keys());
+  }
+  drop(topicId) {
+    this.queue.delete(topicId);
+  }
+  size(topicId) {
+    const bucket = this.queue.get(topicId);
+    return bucket ? bucket.items.length - bucket.head : 0;
+  }
+  remove(topicId, requestId) {
+    const bucket = this.queue.get(topicId);
+    if (!bucket?.requestIds.has(requestId))
+      return;
+    const index = bucket.items.findIndex((entry, entryIndex) => entryIndex >= bucket.head && entry.requestId === requestId);
+    if (index < 0)
+      return;
+    const [removed] = bucket.items.splice(index, 1);
+    bucket.requestIds.delete(requestId);
+    this.compactOrDelete(topicId, bucket);
+    return removed;
+  }
+}
+
+class DeferredInjectBatcher {
+  options;
+  timers = new Map;
+  scheduleTimer;
+  constructor(options) {
+    this.options = options;
+    this.scheduleTimer = options.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+  }
+  enqueue(inject) {
+    const queued = this.options.queue.enqueue(inject.topicId, inject);
+    if (!queued)
+      return false;
+    if (this.timers.has(inject.topicId))
+      return true;
+    const timer = this.scheduleTimer(() => {
+      this.timers.delete(inject.topicId);
+      if (this.options.isBusy(inject.topicId))
+        return;
+      const batch = this.options.queue.dequeueAll(inject.topicId);
+      if (batch)
+        this.options.dispatch(batch);
+    }, this.options.delayMs);
+    this.timers.set(inject.topicId, timer);
+    return true;
+  }
+  isScheduled(topicId) {
+    return this.timers.has(topicId);
+  }
+}
+var interSessionQueue = new InterSessionQueue;
+
+// ../../packages/core/src/storage/topic-archive.ts
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync7 } from "fs";
+import { join as join16 } from "path";
+
+// ../../packages/core/src/storage/topic-transcript.ts
+function parseJsonField(value) {
+  if (!value)
+    return;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function transcriptRole(row) {
+  if (row.author_id === "system")
+    return "system";
+  if (row.author_id === "ai" || row.agent_type)
+    return "assistant";
+  return "user";
+}
+function transcriptSpeaker(row, role) {
+  if (role === "assistant")
+    return row.agent_type ? `assistant:${row.agent_type}` : "assistant";
+  if (role === "system")
+    return "system";
+  return `user:${row.author_id}`;
+}
+function oneLine(text) {
+  const compact = text.replace(/\s+/g, " ").trim();
+  return compact.length > 2000 ? `${compact.slice(0, 2000)}...` : compact;
+}
+function formatTopicArchiveTranscriptRecord(row, topicTitle, index) {
+  const role = transcriptRole(row);
+  const speaker = transcriptSpeaker(row, role);
+  const attachments = parseJsonField(row.attachments);
+  const usage = parseJsonField(row.usage);
+  return {
+    type: "message",
+    index,
+    topicId: row.topic_id,
+    topicTitle,
+    id: row.id,
+    createdAt: row.created_at,
+    ...row.rowid !== undefined ? { rowid: row.rowid } : {},
+    role,
+    speaker,
+    line: `[${row.created_at}] ${speaker}: ${oneLine(row.text)}`,
+    text: row.text,
+    authorId: row.author_id,
+    ...row.parent_id ? { parentId: row.parent_id } : {},
+    ...row.query_id ? { queryId: row.query_id } : {},
+    ...row.agent_type ? { agentType: row.agent_type } : {},
+    ...row.model ? { model: row.model } : {},
+    ...attachments !== undefined ? { attachments } : {},
+    ...usage !== undefined ? { usage } : {},
+    message: row
+  };
+}
+
+// ../../packages/core/src/storage/topic-archive.ts
+function archiveTopicMessages(topicId, topicTitle, options = {}) {
+  const rows = options.afterRowid !== undefined ? getMessagesForTopicAfterRowid(topicId, options.afterRowid) : getAllMessagesForTopic(topicId);
+  if (rows.length === 0)
+    return null;
+  const safeTopic = sanitizeTopicName(topicTitle, true);
+  const archiveDir = join16(getSharedWikiDir(), "archive");
+  mkdirSync9(archiveDir, { recursive: true });
+  const date = new Date().toISOString().slice(0, 10);
+  const reasonSuffix = options.reason && options.reason !== "delete" ? `_${options.reason}` : "";
+  let filename;
+  let counter = 1;
+  const lastRowid = rows.reduce((max, row) => Math.max(max, row.rowid ?? 0), 0);
+  const body = `${rows.map((r, index) => JSON.stringify(formatTopicArchiveTranscriptRecord(r, topicTitle, index + 1))).join(`
+`)}
+`;
+  let path;
+  while (true) {
+    filename = `${safeTopic}_${date}${reasonSuffix}${counter === 1 ? "" : `_${counter}`}.jsonl`;
+    path = join16(archiveDir, filename);
+    try {
+      writeFileSync7(path, body, { flag: "wx" });
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+      counter++;
+    }
+  }
+  logger.info({ topicId, topicTitle, archive: path, messageCount: rows.length, lastRowid }, "archiveTopicMessages: archived topic messages");
+  return { path, messageCount: rows.length, lastRowid };
+}
+
+// ../../packages/core/src/storage/topic-archive-state.ts
+import { rmSync } from "fs";
+registerStorageSchemaInitializer((database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS api_topic_archive_state (
+      topic_id TEXT PRIMARY KEY,
+      last_archived_rowid INTEGER NOT NULL DEFAULT 0,
+      last_archive_path TEXT,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS api_topic_archive_jobs (
+      topic_id TEXT PRIMARY KEY,
+      after_rowid INTEGER NOT NULL,
+      last_rowid INTEGER NOT NULL,
+      archive_path TEXT NOT NULL,
+      message_count INTEGER NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('running', 'pending')),
+      updated_at TEXT NOT NULL
+    );
+  `);
+}, 30);
+var ARCHIVE_JOB_STALE_MS = 30 * 60 * 1000;
+function rowToJob(row) {
+  return {
+    topicId: row.topic_id,
+    afterRowid: row.after_rowid,
+    lastRowid: row.last_rowid,
+    archivePath: row.archive_path,
+    messageCount: row.message_count,
+    status: row.status,
+    updatedAt: row.updated_at
+  };
+}
+function getTopicArchiveState(topicId) {
+  const row = db.query("SELECT * FROM api_topic_archive_state WHERE topic_id = ?").get(topicId);
+  if (!row)
+    return null;
+  return {
+    topicId: row.topic_id,
+    lastArchivedRowid: row.last_archived_rowid,
+    lastArchivePath: row.last_archive_path ?? undefined,
+    updatedAt: row.updated_at
+  };
+}
+function setTopicArchiveState(topicId, lastArchivedRowid, lastArchivePath) {
+  db.query(`INSERT INTO api_topic_archive_state (topic_id, last_archived_rowid, last_archive_path, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(topic_id) DO UPDATE SET
+       last_archived_rowid = excluded.last_archived_rowid,
+       last_archive_path = excluded.last_archive_path,
+       updated_at = excluded.updated_at`).run(topicId, lastArchivedRowid, lastArchivePath ?? null, new Date().toISOString());
+}
+function claimTopicArchiveJob(topicId, create, now = Date.now()) {
+  const claimExisting = () => db.transaction(() => {
+    const existing = db.query("SELECT * FROM api_topic_archive_jobs WHERE topic_id = ?").get(topicId);
+    if (!existing)
+      return null;
+    const updatedAt = Date.parse(existing.updated_at);
+    if (existing.status === "running" && Number.isFinite(updatedAt) && now - updatedAt < ARCHIVE_JOB_STALE_MS) {
+      return { kind: "busy" };
+    }
+    const timestamp = new Date(now).toISOString();
+    db.query("UPDATE api_topic_archive_jobs SET status = 'running', updated_at = ? WHERE topic_id = ?").run(timestamp, topicId);
+    return {
+      kind: "claimed",
+      job: rowToJob({ ...existing, status: "running", updated_at: timestamp })
+    };
+  })();
+  const existingClaim = claimExisting();
+  if (existingClaim)
+    return existingClaim;
+  for (let attempt = 0;attempt < 2; attempt++) {
+    const afterRowid = getTopicArchiveState(topicId)?.lastArchivedRowid ?? 0;
+    const candidate = create(afterRowid);
+    if (!candidate)
+      return null;
+    const result = db.transaction(() => {
+      const existing = db.query("SELECT * FROM api_topic_archive_jobs WHERE topic_id = ?").get(topicId);
+      if (existing)
+        return { kind: "busy" };
+      const currentRowid = getTopicArchiveState(topicId)?.lastArchivedRowid ?? 0;
+      if (currentRowid !== afterRowid)
+        return { kind: "stale" };
+      const timestamp = new Date(now).toISOString();
+      db.query(`INSERT INTO api_topic_archive_jobs
+         (topic_id, after_rowid, last_rowid, archive_path, message_count, status, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'running', ?)`).run(topicId, afterRowid, candidate.lastRowid, candidate.archivePath, candidate.messageCount, timestamp);
+      return {
+        kind: "claimed",
+        job: {
+          topicId,
+          afterRowid,
+          lastRowid: candidate.lastRowid,
+          archivePath: candidate.archivePath,
+          messageCount: candidate.messageCount,
+          status: "running",
+          updatedAt: timestamp
+        }
+      };
+    })();
+    if (result.kind === "claimed")
+      return result;
+    rmSync(candidate.archivePath, { force: true });
+    if (result.kind === "busy")
+      return result;
+  }
+  return claimExisting() ?? { kind: "busy" };
+}
+function settleTopicArchiveJob(topicId, archivePath, success) {
+  db.transaction(() => {
+    const job = db.query("SELECT * FROM api_topic_archive_jobs WHERE topic_id = ? AND archive_path = ?").get(topicId, archivePath);
+    if (!job)
+      return;
+    if (!success) {
+      db.query("UPDATE api_topic_archive_jobs SET status = 'pending', updated_at = ? WHERE topic_id = ? AND archive_path = ?").run(new Date().toISOString(), topicId, archivePath);
+      return;
+    }
+    const current2 = getTopicArchiveState(topicId)?.lastArchivedRowid ?? 0;
+    setTopicArchiveState(topicId, Math.max(current2, job.last_rowid), job.archive_path);
+    db.query("DELETE FROM api_topic_archive_jobs WHERE topic_id = ? AND archive_path = ?").run(topicId, archivePath);
+  })();
+}
+
+// ../../packages/core/src/agents/idle-archiver.ts
+var DEFAULT_IDLE_DELAY_MS = 6 * 60 * 60 * 1000;
+var DEFAULT_MIN_MESSAGES = 8;
+var timers = new Map;
+function envFlagEnabled(name, fallback) {
+  const raw = process.env[name]?.trim().toLowerCase();
+  if (!raw)
+    return fallback;
+  return !["0", "false", "off", "no"].includes(raw);
+}
+function envPositiveInt(name, fallback) {
+  const value = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function idleArchiveDelayMs() {
+  return envPositiveInt("NEGOTIUM_IDLE_ARCHIVE_DELAY_MS", DEFAULT_IDLE_DELAY_MS);
+}
+function idleArchiveMinMessages() {
+  return envPositiveInt("NEGOTIUM_IDLE_ARCHIVE_MIN_MESSAGES", DEFAULT_MIN_MESSAGES);
+}
+function idleArchiverEnabled() {
+  return envFlagEnabled("NEGOTIUM_IDLE_ARCHIVER_ENABLED", true);
+}
+function scheduleIdleArchiveForTopic(topicId, userId) {
+  if (!idleArchiverEnabled())
+    return "disabled";
+  const topic = getTopic(topicId);
+  if (!topic)
+    return "topic-not-found";
+  if (!topic.agent)
+    return "not-ai-invited";
+  if (topic.aiMode === "mention")
+    return "mention-only-channel";
+  const existing = timers.get(topicId);
+  if (existing)
+    clearTimeout(existing);
+  const timer = setTimeout(() => {
+    timers.delete(topicId);
+    runIdleArchiveForTopic(topicId, userId);
+  }, idleArchiveDelayMs());
+  timer.unref?.();
+  timers.set(topicId, timer);
+  return "scheduled";
+}
+function runIdleArchiveForTopic(topicId, userId) {
+  if (!idleArchiverEnabled())
+    return "disabled";
+  return archiveActiveTopicForMemory(topicId, userId, {
+    reason: "idle",
+    minMessages: idleArchiveMinMessages()
+  });
+}
+function archiveActiveTopicForMemory(topicId, userId, options) {
+  if (options.reason === "idle" && !(options.enabled ?? idleArchiverEnabled()))
+    return "disabled";
+  const busy = options.isBusy ? options.isBusy(topicId) : Boolean(getRoomQuery(topicId));
+  if (!options.skipBusyCheck && busy) {
+    if (options.onBusy)
+      options.onBusy(topicId, userId);
+    else
+      scheduleIdleArchiveForTopic(topicId, userId);
+    return "busy";
+  }
+  const topic = getTopic(topicId);
+  if (!topic)
+    return "topic-not-found";
+  if (!topic.agent)
+    return "not-ai-invited";
+  if (!options.allowMentionOnly && topic.aiMode === "mention")
+    return "mention-only-channel";
+  let skipped = "empty";
+  const claim = claimTopicArchiveJob(topicId, (afterRowid) => {
+    const pending = getMessagesForTopicAfterRowid(topicId, afterRowid);
+    const minMessages = options.minMessages;
+    if (pending.length < minMessages) {
+      skipped = "below-threshold";
+      logger.debug({ topicId, topicTitle: topic.title, pending: pending.length, minMessages }, "topic-memory-archiver: skipped below threshold");
+      return null;
+    }
+    const archived = (options.archiveMessages ?? archiveTopicMessages)(topicId, topic.title, {
+      afterRowid,
+      reason: options.reason
+    });
+    if (!archived)
+      return null;
+    return {
+      archivePath: archived.path,
+      messageCount: archived.messageCount,
+      lastRowid: archived.lastRowid
+    };
+  });
+  if (!claim)
+    return skipped;
+  if (claim.kind === "busy")
+    return "busy";
+  const { job } = claim;
+  const memoryTopic = getTopicMemoryOrigin(topicId) ?? topic;
+  const launched = (options.launchArchiver ?? runArchiverTurn)({
+    userId,
+    topicId: memoryTopic.id,
+    topicTitle: memoryTopic.title,
+    archivePath: job.archivePath,
+    messageCount: job.messageCount,
+    mode: "active-topic",
+    onSettled: (success) => settleTopicArchiveJob(topicId, job.archivePath, success)
+  });
+  if (!launched) {
+    settleTopicArchiveJob(topicId, job.archivePath, false);
+    return "deferred";
+  }
+  logger.info({
+    topicId,
+    topicTitle: topic.title,
+    messageCount: job.messageCount,
+    archive: job.archivePath,
+    reason: options.reason
+  }, "topic-memory-archiver: archived active topic snapshot");
+  return "archived";
+}
+// ../../packages/core/src/agents/mcp-tools/visuals.ts
+import { z } from "zod";
+
+// ../../packages/core/src/mcp/mcp-helpers.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function mcpOk(text) {
+  return { content: [{ type: "text", text }] };
+}
+function mcpError(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// ../../packages/core/src/agents/mcp-tools/common.ts
+function textResult(text) {
+  return mcpOk(text);
+}
+function errorResult(text) {
+  return mcpError(text);
+}
+
+// ../../packages/core/src/agents/mcp-tools/visuals.ts
+var VISUALS_MCP_KEY = "visuals";
+var showHtmlTool = {
+  name: "show_html",
+  description: "Display charts, tables, or interactive HTML to the user in a sandboxed WebView side panel. Pass a complete, self-contained HTML string with inline CSS/JS. Local DOM interactions are supported. Links (<a href> to http/https URLs) are safe to include: a click opens the URL in the user's system browser. Network requests, external scripts, form posts, popups, and parent-window access are blocked.",
+  schema: {
+    html: z.string().describe("Complete, self-contained HTML document or fragment to render."),
+    title: z.string().optional().describe("Optional title shown above the rendered card.")
+  },
+  async handler() {
+    return textResult("HTML card displayed to the user.");
+  }
+};
+var showMermaidTool = {
+  name: "show_mermaid",
+  description: "Render a Mermaid diagram in the user's visual side panel. Pass Mermaid DSL only, not markdown fences. Use this for flowcharts, sequence diagrams, class diagrams, state diagrams, ER diagrams, timelines, and architecture diagrams.",
+  schema: {
+    code: z.string().describe("Mermaid diagram source without markdown code fences."),
+    title: z.string().optional().describe("Optional title shown above the rendered card."),
+    theme: z.enum(["default", "neutral", "dark", "forest"]).optional().describe("Optional Mermaid theme. Defaults to neutral.")
+  },
+  async handler() {
+    return textResult("Mermaid diagram displayed to the user.");
+  }
+};
+var showImageTool = {
+  name: "show_image",
+  description: "Display an image in the user's visual side panel. Provide either file_path for an image in the topic workspace, or file_id for an uploaded file already attached in this topic.",
+  schema: {
+    file_path: z.string().optional().describe("Absolute or workspace-relative path to an image file."),
+    file_id: z.string().optional().describe("Full Otium uploaded file UUID for an image attached in this topic."),
+    title: z.string().optional().describe("Optional title shown above the rendered card."),
+    alt: z.string().optional().describe("Optional alt text for the image.")
+  },
+  async handler(input) {
+    if (!input?.file_path && !input?.file_id) {
+      return errorResult("file_path or file_id is required.");
+    }
+    return textResult("Image displayed to the user.");
+  }
+};
+var showVideoTool = {
+  name: "show_video",
+  description: "Display a playable video in the user's visual side panel. Provide either file_path for a video in the topic workspace, or file_id for an uploaded file already attached in this topic.",
+  schema: {
+    file_path: z.string().optional().describe("Absolute or workspace-relative path to a video file."),
+    file_id: z.string().optional().describe("Full Otium uploaded file UUID for a video attached in this topic."),
+    title: z.string().optional().describe("Optional title shown above the rendered card.")
+  },
+  async handler(input) {
+    if (!input?.file_path && !input?.file_id) {
+      return errorResult("file_path or file_id is required.");
+    }
+    return textResult("Video displayed to the user.");
+  }
+};
+var visualToolDefinitions = [
+  showHtmlTool,
+  showMermaidTool,
+  showImageTool,
+  showVideoTool
+];
+
+// ../../packages/core/src/agents/mcp-tools/visual-compat.ts
+var showPngTool = {
+  name: "show_png",
+  description: "Backward-compatible alias for show_image. Display a PNG or other image from this topic's workspace or an uploaded file in the visual side panel.",
+  schema: showImageTool.schema,
+  handler: showImageTool.handler
+};
+var otiumVisualToolDefinitions = [
+  showHtmlTool,
+  showMermaidTool,
+  showImageTool,
+  showPngTool,
+  showVideoTool
+];
 export {
   withTaskSnapshots,
   withCodexSpawnSerial,
+  visualToolDefinitions,
   unregisterOwnedCodexPids,
   snapshotCodexChildren,
+  showVideoTool,
+  showPngTool,
+  showMermaidTool,
+  showImageTool,
+  showHtmlTool,
   shouldRedirectVaultTool,
   resolveTaskEventScope,
   registerOwnedCodexPids,
   referencesRuntimeSecretStorage,
+  otiumVisualToolDefinitions,
   killOwnedCodexTreesForShutdown,
   killCodexTrees,
   isVaultBrokerTool,
@@ -1757,8 +6249,10 @@ export {
   createAgentForkHelpers,
   cleanupAgentFork,
   checkAgentAuth,
+  archiveActiveTopicForMemory,
   acquireCodexSpawnLock,
+  VISUALS_MCP_KEY,
   VAULT_BROKER_REDIRECT_ERROR
 };
 
-//# debugId=3205ED8BFB73168364756E2164756E21
+//# debugId=03A8268BD14CA74064756E2164756E21