negotium 0.2.18 → 0.2.20

package/dist/mcp-factories.js

@@ -29,6 +29,59 @@ var init_types = __esm(() => {
   MAESTRO_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max"];
 });
 
+// ../../packages/core/src/storage/sqlite.ts
+var isBun, Database;
+var init_sqlite = __esm(async () => {
+  isBun = typeof process.versions.bun === "string";
+  if (isBun) {
+    ({ Database } = await import("bun:sqlite"));
+  } else {
+    const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
+    const { DatabaseSync } = await import(nodeSqliteSpecifier);
+
+    class NodeDatabase {
+      #db;
+      constructor(path, options = {}) {
+        this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
+      }
+      query(sql) {
+        return this.#db.prepare(sql);
+      }
+      prepare(sql) {
+        return this.#db.prepare(sql);
+      }
+      exec(sql) {
+        this.#db.exec(sql);
+      }
+      run(sql, ...params) {
+        return this.#db.prepare(sql).run(...params);
+      }
+      transaction(fn) {
+        const run = (begin) => (...args) => {
+          this.#db.exec(begin);
+          try {
+            const result = fn(...args);
+            this.#db.exec("COMMIT");
+            return result;
+          } catch (err) {
+            this.#db.exec("ROLLBACK");
+            throw err;
+          }
+        };
+        const tx = run("BEGIN");
+        tx.deferred = run("BEGIN DEFERRED");
+        tx.immediate = run("BEGIN IMMEDIATE");
+        tx.exclusive = run("BEGIN EXCLUSIVE");
+        return tx;
+      }
+      close() {
+        this.#db.close();
+      }
+    }
+    Database = NodeDatabase;
+  }
+});
+
 // ../../packages/core/src/platform/config-helpers.ts
 function readEnvText(env, key) {
   const value2 = env[key]?.trim();
@@ -72,11 +125,11 @@ import { execFileSync } from "child_process";
 import { randomBytes } from "crypto";
 import {
   accessSync,
-  chmodSync,
+  chmodSync as chmodSync2,
   constants,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   writeFileSync
 } from "fs";
 import { createRequire } from "module";
@@ -93,7 +146,7 @@ function resolveAgentEnv(envKey, fallback, legacyEnvKey) {
 function resolveProjectRoot() {
   const moduleDir = dirname(fileURLToPath(import.meta.url));
   const packagedRuntime = resolve(moduleDir, "runtime");
-  if (existsSync(resolve(packagedRuntime, "src")))
+  if (existsSync2(resolve(packagedRuntime, "src")))
     return packagedRuntime;
   return resolve(moduleDir, "../..");
 }
@@ -101,7 +154,7 @@ function resolveDependencyBin(name) {
   let dir = PROJECT_ROOT;
   while (true) {
     const candidate = resolve(dir, "node_modules", ".bin", name);
-    if (existsSync(candidate))
+    if (existsSync2(candidate))
       return candidate;
     const parent = dirname(dir);
     if (parent === dir)
@@ -139,7 +192,7 @@ function browserRsMeetsMinimumVersion(candidate) {
   try {
     const output = execFileSync(candidate, ["--version"], {
       encoding: "utf8",
-      timeout: 2000,
+      timeout: BROWSER_RS_VERSION_PROBE_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
     const match = output.match(/^browser-rs (\d+)\.(\d+)\.(\d+)$/);
@@ -215,14 +268,14 @@ function loadOrCreateLocalSecret(envKey, filename, options = {}) {
     if (options.persistEnvValue) {
       writeFileSync(secretFile, `${envValue}
 `, { mode: 384 });
-      chmodSync(secretFile, 384);
+      chmodSync2(secretFile, 384);
     }
     return envValue;
   }
-  if (existsSync(secretFile)) {
-    const stored = readFileSync(secretFile, "utf-8").trim();
+  if (existsSync2(secretFile)) {
+    const stored = readFileSync2(secretFile, "utf-8").trim();
     if (stored) {
-      chmodSync(secretFile, 384);
+      chmodSync2(secretFile, 384);
       return stored;
     }
   }
@@ -234,10 +287,10 @@ function loadOrCreateLocalSecret(envKey, filename, options = {}) {
   } catch (error) {
     if (error.code !== "EEXIST")
       throw error;
-    const stored = readFileSync(secretFile, "utf-8").trim();
+    const stored = readFileSync2(secretFile, "utf-8").trim();
     if (!stored)
       throw new Error(`Secret file exists but is empty: ${secretFile}`);
-    chmodSync(secretFile, 384);
+    chmodSync2(secretFile, 384);
     return stored;
   }
 }
@@ -250,7 +303,7 @@ function resolveDefaultModel(agent, registryDefaultModel) {
 function codexAuthFilePath() {
   return process.env.NEGOTIUM_CODEX_AUTH_FILE || join(process.env.CODEX_HOME || join(homedir(), ".codex"), "auth.json");
 }
-var HOME, PROJECT_ROOT, STATE_DIR_ENV, STATE_DIR, WORKSPACE_DIR, TOPIC_WORKSPACE_DIR, SHARED_WIKI_DIR, CRON_WORKSPACE_DIR, BROWSER_DIR, BROWSER_PROFILES_DIR, BINARIES_DIR, SECRETS_DIR, DM_WORKSPACE_DIR, SESSION_WORKSPACE_DIR, CLAUDE_EXECUTABLE_ENV, CLAUDE_EXECUTABLE, DEFAULT_OUTPUT_LANGUAGE = "English", BROWSER_RS_VERSION = "v0.1.19", BROWSER_RS_MIN_SECURE_VERSION = "0.1.15", SNIPPETS_API_URL, BROWSER_RS_BIN, BASH_RS_VERSION = "v0.1.5", BASH_RS_BIN, PLAYWRIGHT_MCP_BIN, TSX_BIN, TSX_LOADER, TSCONFIG_PATH, SESSION_COMM_SERVER, TASK_SERVER, BROWSER_MCP_SSE_PROXY_SERVER, CANONICAL_MCP_PROXY_SERVER, WIKI_SERVER, TOKEN_STATS_SERVER, COMPACTION_LOG_SERVER, SYSTEM_HEALTH_SERVER, AGENT_HEALTH_SERVER, VAULT_SERVER, BG_BASH_BASE_PORT, BG_BASH_MAX_PORT, RUNTIME_MCP_SECRET, NODE_CONTROL_TOKEN, VAULT_MASTER_KEY, NEGOTIUM_PORT, hostname, DATA_DIR, LOG_DIR, UPLOADS_DIR, VAULT_DIR, SESSIONS_DB, DEBUG_FILE, USERS_LOG_DIR, RUN_DIR, PROGRESS_DIR, DM_CMD_DIR, DM_RESP_DIR, SESSION_INBOX_DIR, SESSION_ASKS_DIR, BASHRS_SPILL_ROOT, PLAYWRIGHT_BASE_PORT, PLAYWRIGHT_MAX_PORT, PLAYWRIGHT_PORTS_DIR, ACTIVE_QUERY_STALE_MS, AGENTS_PROMPTS_DIR, RESOURCES_DIR, FILE_TAG_REGEX, MODEL_SONNET = "claude-sonnet-5", MODEL_OPUS = "claude-opus-5", MODEL_FABLE = "claude-fable-5", FALLBACK_AGENT, SESSION_AGENT, GATEWAY_AGENT, FALLBACK_MODEL, SESSION_MODEL, GATEWAY_MODEL, FFMPEG_BIN, FFPROBE_BIN, PYTHON_BIN, FASTER_WHISPER_WRAPPER, WHISPER_MODEL, TESSERACT_BIN, PDFTOTEXT_BIN, _envMaxTellDepth, MAX_TELL_DEPTH;
+var HOME, PROJECT_ROOT, STATE_DIR_ENV, STATE_DIR, WORKSPACE_DIR, TOPIC_WORKSPACE_DIR, SHARED_WIKI_DIR, CRON_WORKSPACE_DIR, BROWSER_DIR, BROWSER_PROFILES_DIR, BINARIES_DIR, SECRETS_DIR, DM_WORKSPACE_DIR, SESSION_WORKSPACE_DIR, CLAUDE_EXECUTABLE_ENV, CLAUDE_EXECUTABLE, DEFAULT_OUTPUT_LANGUAGE = "English", BROWSER_RS_VERSION = "v0.1.19", BROWSER_RS_MIN_SECURE_VERSION = "0.1.15", BROWSER_RS_VERSION_PROBE_TIMEOUT_MS = 15000, SNIPPETS_API_URL, BROWSER_RS_BIN, BASH_RS_VERSION = "v0.1.5", BASH_RS_BIN, PLAYWRIGHT_MCP_BIN, TSX_BIN, TSX_LOADER, TSCONFIG_PATH, SESSION_COMM_SERVER, TASK_SERVER, BROWSER_MCP_SSE_PROXY_SERVER, CANONICAL_MCP_PROXY_SERVER, WIKI_SERVER, TOKEN_STATS_SERVER, COMPACTION_LOG_SERVER, SYSTEM_HEALTH_SERVER, AGENT_HEALTH_SERVER, VAULT_SERVER, BG_BASH_BASE_PORT, BG_BASH_MAX_PORT, RUNTIME_MCP_SECRET, NODE_CONTROL_TOKEN, VAULT_MASTER_KEY, NEGOTIUM_PORT, hostname, DATA_DIR, LOG_DIR, UPLOADS_DIR, VAULT_DIR, SESSIONS_DB, DEBUG_FILE, USERS_LOG_DIR, RUN_DIR, PROGRESS_DIR, DM_CMD_DIR, DM_RESP_DIR, SESSION_INBOX_DIR, SESSION_ASKS_DIR, BASHRS_SPILL_ROOT, PLAYWRIGHT_BASE_PORT, PLAYWRIGHT_MAX_PORT, PLAYWRIGHT_PORTS_DIR, ACTIVE_QUERY_STALE_MS, AGENTS_PROMPTS_DIR, RESOURCES_DIR, FILE_TAG_REGEX, MODEL_SONNET = "claude-sonnet-5", MODEL_OPUS = "claude-opus-5", MODEL_FABLE = "claude-fable-5", FALLBACK_AGENT, SESSION_AGENT, GATEWAY_AGENT, FALLBACK_MODEL, SESSION_MODEL, GATEWAY_MODEL, FFMPEG_BIN, FFPROBE_BIN, PYTHON_BIN, FASTER_WHISPER_WRAPPER, WHISPER_MODEL, TESSERACT_BIN, PDFTOTEXT_BIN, _envMaxTellDepth, MAX_TELL_DEPTH;
 var init_config = __esm(() => {
   init_config_helpers();
   init_logger();
@@ -569,7 +622,7 @@ var init_shared = __esm(() => {
 });
 
 // ../../packages/core/src/platform/file-utils.ts
-import { unlinkSync as unlinkSync2 } from "fs";
+import { unlinkSync as unlinkSync3 } from "fs";
 function createSafeUnlink(host) {
   return (path, warnLabel) => {
     try {
@@ -589,7 +642,7 @@ var defaultSafeUnlink;
 var init_file_utils = __esm(() => {
   init_logger();
   defaultSafeUnlink = createSafeUnlink({
-    unlink: unlinkSync2,
+    unlink: unlinkSync3,
     warn: (context, message) => logger.warn(context, message)
   });
 });
@@ -601,15 +654,15 @@ import {
   fsyncSync,
   mkdirSync as mkdirSync4,
   openSync as openSync2,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   renameSync as renameSync2,
   statSync as statSync2,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync3
 } from "fs";
 import { dirname as dirname3 } from "path";
 function readJsonlLines(filePath) {
-  return readFileSync3(filePath, "utf-8").trim().split(`
+  return readFileSync4(filePath, "utf-8").trim().split(`
 `).filter(Boolean);
 }
 function parseJsonlText(raw) {
@@ -618,7 +671,7 @@ function parseJsonlText(raw) {
 }
 function readJsonFile(filePath) {
   try {
-    return JSON.parse(readFileSync3(filePath, "utf-8"));
+    return JSON.parse(readFileSync4(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -708,7 +761,7 @@ function writeJsonlFile(filePath, entries) {
       } catch {}
     }
     try {
-      unlinkSync3(tmpPath);
+      unlinkSync4(tmpPath);
     } catch {}
     throw err;
   }
@@ -744,13 +797,13 @@ var init_jsonl = __esm(() => {
 
 // ../../packages/core/src/agents/rollout/claude.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 function loadClaudeAttachments() {
   if (_attachmentsCache)
     return _attachmentsCache;
-  const raw = readFileSync4(join3(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
+  const raw = readFileSync5(join3(FIXTURES_DIR, "claude-attachments.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 2) {
     throw new Error(`loadClaudeAttachments: expected >=2 entries in claude-attachments.jsonl, got ${lines.length}`);
@@ -865,7 +918,7 @@ var init_claude = __esm(() => {
 });
 
 // ../../packages/core/src/agents/claude-registry.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readdirSync as readdirSync2, renameSync as renameSync3, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync2, renameSync as renameSync3, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 var ALIAS_MAP, VALID_ALIASES, VALID_EFFORTS, claudeRegistry, claudeRegistryOperations;
@@ -917,8 +970,8 @@ var init_claude_registry = __esm(() => {
       const projectsRoot = join4(homedir3(), ".claude", "projects");
       const destDir = join4(projectsRoot, encodeClaudeCwd(cwd));
       const destPath = join4(destDir, `${result.sessionId}.jsonl`);
-      if (!existsSync4(destPath)) {
-        const sourcePath = readdirSync2(projectsRoot).map((d) => join4(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync4(p));
+      if (!existsSync5(destPath)) {
+        const sourcePath = readdirSync2(projectsRoot).map((d) => join4(projectsRoot, d, `${result.sessionId}.jsonl`)).find((p) => existsSync5(p));
         if (!sourcePath) {
           throw new Error(`claude forkSession: fork rollout ${result.sessionId}.jsonl not found under ${projectsRoot}`);
         }
@@ -936,7 +989,7 @@ var init_claude_registry = __esm(() => {
       for (const sid of sessionIds) {
         const path = join4(projectsDir, `${sid}.jsonl`);
         try {
-          unlinkSync4(path);
+          unlinkSync5(path);
         } catch (e) {
           if (e?.code !== "ENOENT") {
             logger.warn({ err: e, path }, "claude cleanupRollouts: unlink failed");
@@ -952,27 +1005,27 @@ var init_claude_registry = __esm(() => {
 });
 
 // ../../packages/core/src/version.ts
-var NEGOTIUM_VERSION = "0.2.18";
+var NEGOTIUM_VERSION = "0.2.20";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn as spawn2 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import {
-  chmodSync as chmodSync2,
+  chmodSync as chmodSync3,
   copyFileSync,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdtempSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   renameSync as renameSync4,
   rmSync,
-  unlinkSync as unlinkSync5,
+  unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { tmpdir } from "os";
 import { dirname as dirname4, join as join5 } from "path";
 function readPackageVersion(packageJsonPath) {
-  const parsed = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
+  const parsed = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
   if (typeof parsed.version !== "string" || !parsed.version.trim()) {
     throw new Error(`Codex package has no valid version: ${packageJsonPath}`);
   }
@@ -994,7 +1047,7 @@ function parseCodexModelCache(contents, sourcePath) {
   return parsed;
 }
 function readCodexModelCache(cachePath) {
-  const contents = readFileSync5(cachePath, "utf8");
+  const contents = readFileSync6(cachePath, "utf8");
   return { contents, parsed: parseCodexModelCache(contents, cachePath) };
 }
 function readCompatibleCodexModelCache(cachePath) {
@@ -1006,16 +1059,16 @@ function readCompatibleCodexModelCache(cachePath) {
   return cache;
 }
 function writePrivateFileAtomic(path, contents) {
-  if (existsSync5(path) && readFileSync5(path, "utf8") === contents)
+  if (existsSync6(path) && readFileSync6(path, "utf8") === contents)
     return;
   const tempPath = `${path}.${process.pid}.${randomUUID3()}.tmp`;
   try {
     writeFileSync5(tempPath, contents, { encoding: "utf8", mode: 384 });
     renameSync4(tempPath, path);
-    chmodSync2(path, 384);
+    chmodSync3(path, 384);
   } finally {
     try {
-      unlinkSync5(tempPath);
+      unlinkSync6(tempPath);
     } catch {}
   }
 }
@@ -1043,7 +1096,7 @@ async function bootstrapCodexModelCache(codexHome, cachePath) {
       } catch {}
       if (error)
         reject(error);
-      else if (!existsSync5(cachePath))
+      else if (!existsSync6(cachePath))
         reject(new Error("Codex did not create its model cache"));
       else
         resolve4();
@@ -1111,12 +1164,12 @@ async function bootstrapIsolatedCodexModelCache(authFilePath, bootstrap) {
   try {
     const isolatedAuthPath = join5(isolatedHome, "auth.json");
     copyFileSync(authFilePath, isolatedAuthPath);
-    chmodSync2(isolatedAuthPath, 384);
+    chmodSync3(isolatedAuthPath, 384);
     const sourceConfigPath = join5(sourceHome, "config.toml");
-    if (existsSync5(sourceConfigPath)) {
+    if (existsSync6(sourceConfigPath)) {
       const isolatedConfigPath = join5(isolatedHome, "config.toml");
       copyFileSync(sourceConfigPath, isolatedConfigPath);
-      chmodSync2(isolatedConfigPath, 384);
+      chmodSync3(isolatedConfigPath, 384);
     }
     await bootstrap(isolatedHome, isolatedCachePath);
     return readCompatibleCodexModelCache(isolatedCachePath).contents;
@@ -1128,7 +1181,7 @@ async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexMod
   const codexHome = dirname4(authFilePath);
   const configuredCachePath = process.env.NEGOTIUM_CODEX_MODELS_CACHE_FILE;
   if (configuredCachePath) {
-    if (!existsSync5(configuredCachePath)) {
+    if (!existsSync6(configuredCachePath)) {
       throw new Error(`Configured Codex model cache does not exist: ${configuredCachePath}`);
     }
     readCompatibleCodexModelCache(configuredCachePath);
@@ -1136,14 +1189,14 @@ async function ensureCodexModelCache(authFilePath, bootstrap = bootstrapCodexMod
   }
   const bundledCachePath = bundledCodexModelCachePath(authFilePath);
   const sharedCachePath = join5(codexHome, "models_cache.json");
-  if (existsSync5(sharedCachePath)) {
+  if (existsSync6(sharedCachePath)) {
     try {
       const shared = readCompatibleCodexModelCache(sharedCachePath);
       writePrivateFileAtomic(bundledCachePath, shared.contents);
       return bundledCachePath;
     } catch {}
   }
-  if (existsSync5(bundledCachePath)) {
+  if (existsSync6(bundledCachePath)) {
     try {
       readCompatibleCodexModelCache(bundledCachePath);
       return bundledCachePath;
@@ -2188,57 +2241,161 @@ var init_mcp_config = __esm(() => {
   nodeMcpEntries = [];
 });
 
-// ../../packages/core/src/storage/sqlite.ts
-var isBun, Database;
-var init_sqlite = __esm(async () => {
-  isBun = typeof process.versions.bun === "string";
-  if (isBun) {
-    ({ Database } = await import("bun:sqlite"));
-  } else {
-    const nodeSqliteSpecifier = ["node", "sqlite"].join(":");
-    const { DatabaseSync } = await import(nodeSqliteSpecifier);
-
-    class NodeDatabase {
-      #db;
-      constructor(path, options = {}) {
-        this.#db = options.readonly ? new DatabaseSync(path, { readOnly: true }) : new DatabaseSync(path);
-      }
-      query(sql) {
-        return this.#db.prepare(sql);
-      }
-      prepare(sql) {
-        return this.#db.prepare(sql);
-      }
-      exec(sql) {
-        this.#db.exec(sql);
-      }
-      run(sql, ...params) {
-        return this.#db.prepare(sql).run(...params);
-      }
-      transaction(fn) {
-        const run = (begin) => (...args) => {
-          this.#db.exec(begin);
-          try {
-            const result = fn(...args);
-            this.#db.exec("COMMIT");
-            return result;
-          } catch (err) {
-            this.#db.exec("ROLLBACK");
-            throw err;
-          }
-        };
-        const tx = run("BEGIN");
-        tx.deferred = run("BEGIN DEFERRED");
-        tx.immediate = run("BEGIN IMMEDIATE");
-        tx.exclusive = run("BEGIN EXCLUSIVE");
-        return tx;
-      }
-      close() {
-        this.#db.close();
+// ../../packages/core/src/storage/storage-host.ts
+import { mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname5, join as join6, resolve as resolve5 } from "path";
+function storageState() {
+  const holder = globalThis;
+  const existing = holder[STORAGE_HOST_STATE];
+  if (existing)
+    return existing;
+  const created = {
+    configuredHost: {},
+    fallbackDatabase: null,
+    fallbackDatabasePath: null,
+    frames: [],
+    schemaInitializers: [],
+    initializedSchemas: new WeakMap,
+    initializingDatabases: new WeakSet
+  };
+  Object.defineProperty(holder, STORAGE_HOST_STATE, {
+    value: created,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return created;
+}
+function envPath(name, fallback) {
+  const value2 = process.env[name]?.trim();
+  return resolve5(value2 || fallback);
+}
+function defaultStateDir() {
+  return envPath("NEGOTIUM_STATE_DIR", join6(homedir4(), ".negotium"));
+}
+function defaultDataDir() {
+  return envPath("NEGOTIUM_DATA_DIR", join6(defaultStateDir(), "data"));
+}
+function defaultLogDir() {
+  return envPath("NEGOTIUM_LOG_DIR", join6(defaultStateDir(), "logs"));
+}
+function defaultWorkspaceDir() {
+  return envPath("NEGOTIUM_WORKSPACE_DIR", join6(defaultStateDir(), "workspace"));
+}
+function defaultSessionAsksDir() {
+  const runDir = envPath("NEGOTIUM_RUN_DIR", join6(defaultStateDir(), "runtime"));
+  return join6(runDir, "session-asks");
+}
+function defaultSessionsDatabasePath() {
+  return envPath("SESSIONS_DB_PATH", join6(resolveStorageDataDir(), "sessions.db"));
+}
+function isSqliteBusy(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /database is (?:locked|busy)|SQLITE_(?:BUSY|LOCKED)/i.test(message);
+}
+function execWithBusyRetry(database, sql, timeoutMs = SQLITE_INIT_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      database.exec(sql);
+      return;
+    } catch (error) {
+      if (!isSqliteBusy(error) || Date.now() >= deadline)
+        throw error;
+      Atomics.wait(SQLITE_INIT_SLEEP, 0, 0, Math.min(SQLITE_INIT_RETRY_MS, deadline - Date.now()));
+    }
+  }
+}
+function initializeDatabase(database) {
+  database.exec("PRAGMA busy_timeout = 5000");
+  execWithBusyRetry(database, "PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+  } catch {}
+}
+function defaultDatabase() {
+  const path = defaultSessionsDatabasePath();
+  const state = storageState();
+  if (state.fallbackDatabase && state.fallbackDatabasePath === path)
+    return state.fallbackDatabase;
+  if (state.fallbackDatabase)
+    state.fallbackDatabase.close();
+  mkdirSync6(dirname5(path), { recursive: true });
+  state.fallbackDatabase = new Database(path, { create: true });
+  state.fallbackDatabasePath = path;
+  initializeDatabase(state.fallbackDatabase);
+  return state.fallbackDatabase;
+}
+function resolveStorageDatabase() {
+  return storageState().configuredHost.database ?? defaultDatabase();
+}
+function resolveStorageDataDir() {
+  return storageState().configuredHost.dataDir ?? defaultDataDir();
+}
+function resolveStorageLogDir() {
+  return storageState().configuredHost.logDir ?? defaultLogDir();
+}
+function resolveStorageSessionAsksDir() {
+  return storageState().configuredHost.sessionAsksDir ?? defaultSessionAsksDir();
+}
+function resolveStorageWorkspaceDir() {
+  return storageState().configuredHost.workspaceDir ?? defaultWorkspaceDir();
+}
+function resolveStorageSharedWikiDir() {
+  return storageState().configuredHost.sharedWikiDir ?? join6(resolveStorageWorkspaceDir(), "wiki");
+}
+function registerStorageSchemaInitializer(initialize, priority = 100) {
+  const initializers = storageState().schemaInitializers;
+  initializers.push({ initialize, priority });
+  initializers.sort((a, b) => a.priority - b.priority);
+}
+function ensureStorageSchemas(database = resolveStorageDatabase()) {
+  const state = storageState();
+  if (state.initializingDatabases.has(database))
+    return;
+  let initialized = state.initializedSchemas.get(database);
+  if (!initialized) {
+    initialized = new Set;
+    state.initializedSchemas.set(database, initialized);
+  }
+  state.initializingDatabases.add(database);
+  try {
+    for (const entry of state.schemaInitializers) {
+      if (initialized.has(entry.initialize))
+        continue;
+      initialized.add(entry.initialize);
+      try {
+        entry.initialize(database);
+      } catch (error) {
+        initialized.delete(entry.initialize);
+        throw error;
       }
     }
-    Database = NodeDatabase;
+  } finally {
+    state.initializingDatabases.delete(database);
   }
+}
+var STORAGE_HOST_STATE, SQLITE_INIT_RETRY_MS = 25, SQLITE_INIT_TIMEOUT_MS = 5000, SQLITE_INIT_SLEEP, internalStorageDatabase;
+var init_storage_host = __esm(async () => {
+  await init_sqlite();
+  STORAGE_HOST_STATE = Symbol.for("negotium.storage-host.state.v1");
+  SQLITE_INIT_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+  internalStorageDatabase = new Proxy({}, {
+    get(_target, property) {
+      const database = resolveStorageDatabase();
+      ensureStorageSchemas(database);
+      const value2 = Reflect.get(database, property, database);
+      return typeof value2 === "function" ? value2.bind(database) : value2;
+    },
+    set(_target, property, value2) {
+      const database = resolveStorageDatabase();
+      ensureStorageSchemas(database);
+      return Reflect.set(database, property, value2, database);
+    }
+  });
 });
 
 // ../../packages/core/src/storage/vault-crypto-core.ts
@@ -2297,8 +2454,8 @@ var init_vault_crypto = __esm(() => {
 });
 
 // ../../packages/core/src/storage/vault.ts
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync6 } from "fs";
-import { join as join6 } from "path";
+import { chmodSync as chmodSync4, mkdirSync as mkdirSync7 } from "fs";
+import { join as join7 } from "path";
 function initializeVaultDatabase(database) {
   database.exec("PRAGMA journal_mode = WAL");
   database.exec("PRAGMA busy_timeout = 5000");
@@ -2333,17 +2490,18 @@ function initializeVaultDatabase(database) {
   }
 }
 function openVaultDatabase(dataDir) {
-  const vaultDir = join6(dataDir, "vault");
-  const path = join6(vaultDir, "vault.db");
-  mkdirSync6(vaultDir, { recursive: true, mode: 448 });
+  const vaultDir = join7(dataDir, "vault");
+  const path = join7(vaultDir, "vault.db");
+  mkdirSync7(vaultDir, { recursive: true, mode: 448 });
   const database = new Database(path, { create: true });
-  chmodSync3(path, 384);
+  chmodSync4(path, 384);
   initializeVaultDatabase(database);
   return database;
 }
 function activeVaultDatabase() {
-  if (!vaultDb)
-    vaultDb = openVaultDatabase(DATA_DIR);
+  if (!vaultDb) {
+    vaultDb = openVaultDatabase(resolveStorageDataDir());
+  }
   return vaultDb;
 }
 function normalizeVaultKey(key) {
@@ -2433,14 +2591,17 @@ var vaultDb, vaultMasterKey, VAULT_VALUE_MAX_BYTES;
 var init_vault = __esm(async () => {
   init_config();
   init_vault_crypto();
-  await init_sqlite();
+  await __promiseAll([
+    init_sqlite(),
+    init_storage_host()
+  ]);
   vaultMasterKey = VAULT_MASTER_KEY;
   VAULT_VALUE_MAX_BYTES = 64 * 1024;
 });
 
 // ../../packages/core/src/agents/execution-host.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { dirname as dirname5 } from "path";
+import { dirname as dirname6 } from "path";
 function activeHost() {
   const scoped = scopedHost.getStore();
   if (scoped)
@@ -2475,7 +2636,7 @@ function hostedCodexAuthFilePath() {
   return activeHost().codexAuthFilePath();
 }
 function hostedCodexHomePath() {
-  return dirname5(hostedCodexAuthFilePath());
+  return dirname6(hostedCodexAuthFilePath());
 }
 var defaultHost, hostRegistrations, scopedHost;
 var init_execution_host = __esm(async () => {
@@ -2498,15 +2659,15 @@ var init_execution_host = __esm(async () => {
 
 // ../../packages/core/src/agents/rollout/codex.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync6, realpathSync as realpathSync2, statSync as statSync3, unlinkSync as unlinkSync6 } from "fs";
-import { basename as basename2, dirname as dirname6, join as join7, resolve as resolve5 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7, realpathSync as realpathSync2, statSync as statSync3, unlinkSync as unlinkSync7 } from "fs";
+import { basename as basename2, dirname as dirname7, join as join8, resolve as resolve6 } from "path";
 function codexSessionsDir() {
-  return join7(hostedCodexHomePath(), "sessions");
+  return join8(hostedCodexHomePath(), "sessions");
 }
 function loadCodexShell() {
   if (_shellCache)
     return _shellCache;
-  const raw = readFileSync6(join7(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
+  const raw = readFileSync7(join8(FIXTURES_DIR, "codex-shell.jsonl"), "utf8");
   const lines = parseJsonlText(raw);
   if (lines.length < 5) {
     throw new Error(`loadCodexShell: expected >=5 entries in codex-shell.jsonl, got ${lines.length}`);
@@ -2573,16 +2734,16 @@ function codexRolloutPath(threadId, fallback) {
   const hh = String(createdAt.getHours()).padStart(2, "0");
   const min = String(createdAt.getMinutes()).padStart(2, "0");
   const ss = String(createdAt.getSeconds()).padStart(2, "0");
-  const dir = join7(codexSessionsDir(), yyyy, mm, dd);
-  return join7(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
+  const dir = join8(codexSessionsDir(), yyyy, mm, dd);
+  return join8(dir, `rollout-${yyyy}-${mm}-${dd}T${hh}-${min}-${ss}-${threadId}.jsonl`);
 }
 function canonicalFilePath(path) {
-  const absolute = resolve5(path);
+  const absolute = resolve6(path);
   try {
     return realpathSync2(absolute);
   } catch {
     try {
-      return join7(realpathSync2(dirname6(absolute)), basename2(absolute));
+      return join8(realpathSync2(dirname7(absolute)), basename2(absolute));
     } catch {
       return absolute;
     }
@@ -2692,7 +2853,7 @@ function readCodexPatchCallIds(threadId) {
   if (!path)
     return [];
   try {
-    return extractCodexPatchCallIds(readFileSync6(path, "utf8"));
+    return extractCodexPatchCallIds(readFileSync7(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch ids: rollout read failed");
     return [];
@@ -2703,7 +2864,7 @@ function readLatestCodexPatchPreview(threadId, expectedPaths, consumedCallIds =
   if (!path)
     return;
   try {
-    return extractLatestCodexPatchPreview(readFileSync6(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
+    return extractLatestCodexPatchPreview(readFileSync7(path, "utf8"), expectedPaths, consumedCallIds, expectedCallId);
   } catch (error) {
     logger.debug({ error, threadId }, "codex patch preview: rollout read failed");
     return;
@@ -2761,7 +2922,7 @@ function readLatestCodexContextUsage(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexContextUsage(readFileSync6(path, "utf8"));
+    return extractLatestCodexContextUsage(readFileSync7(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex context usage: rollout read failed");
     return;
@@ -2772,7 +2933,7 @@ function readLatestCodexTokenTotals(threadId) {
   if (!path)
     return;
   try {
-    return extractLatestCodexTokenTotals(readFileSync6(path, "utf8"));
+    return extractLatestCodexTokenTotals(readFileSync7(path, "utf8"));
   } catch (error) {
     logger.debug({ error, threadId }, "codex token totals: rollout read failed");
     return;
@@ -2783,7 +2944,7 @@ function migrateCodexRolloutNativeMultiAgentMetadata(threadId) {
   if (!path)
     return false;
   try {
-    const entries = parseJsonlText(readFileSync6(path, "utf8"));
+    const entries = parseJsonlText(readFileSync7(path, "utf8"));
     let changed = false;
     for (const entry of entries) {
       if (entry.type !== "session_meta" && entry.type !== "turn_context")
@@ -2812,19 +2973,19 @@ function latestCodexRolloutPath(threadId) {
   try {
     if (buckets) {
       for (const bucket of buckets) {
-        const dir = join7(sessionsDir, bucket);
-        if (!existsSync6(dir))
+        const dir = join8(sessionsDir, bucket);
+        if (!existsSync7(dir))
           continue;
         const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
         for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-          candidates.push(join7(dir, rel));
+          candidates.push(join8(dir, rel));
         }
       }
     }
     if (candidates.length === 0) {
       const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-        candidates.push(join7(sessionsDir, rel));
+        candidates.push(join8(sessionsDir, rel));
       }
     }
     return candidates.sort((a, b) => statSync3(b).mtimeMs - statSync3(a).mtimeMs)[0];
@@ -2945,15 +3106,15 @@ function sweepPriorRolloutsForThread(threadId) {
     return;
   }
   for (const bucket of buckets) {
-    const dir = join7(sessionsDir, bucket);
-    if (!existsSync6(dir))
+    const dir = join8(sessionsDir, bucket);
+    if (!existsSync7(dir))
       continue;
     try {
       const glob = new Bun.Glob(`rollout-*-${threadId}.jsonl`);
       for (const rel of glob.scanSync({ cwd: dir, onlyFiles: true })) {
-        const fullPath = join7(dir, rel);
+        const fullPath = join8(dir, rel);
         try {
-          unlinkSync6(fullPath);
+          unlinkSync7(fullPath);
         } catch (e) {
           if (e?.code !== "ENOENT") {
             logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -2969,9 +3130,9 @@ function sweepPriorRolloutsFullTree(threadId, sessionsDir) {
   try {
     const glob = new Bun.Glob(`**/rollout-*-${threadId}.jsonl`);
     for (const rel of glob.scanSync({ cwd: sessionsDir, onlyFiles: true })) {
-      const fullPath = join7(sessionsDir, rel);
+      const fullPath = join8(sessionsDir, rel);
       try {
-        unlinkSync6(fullPath);
+        unlinkSync7(fullPath);
       } catch (e) {
         if (e?.code !== "ENOENT") {
           logger.warn({ err: e, path: fullPath }, "writeCodexRollout: prior-rollout unlink failed (continuing)");
@@ -3035,7 +3196,7 @@ import { spawn as spawn4 } from "child_process";
 function createCodexAppServerForker(host) {
   return async (parentThreadId) => {
     const child = host.spawnServer();
-    return await new Promise((resolve6, reject) => {
+    return await new Promise((resolve7, reject) => {
       let settled = false;
       let stdoutBuffer = "";
       let stderr = "";
@@ -3052,7 +3213,7 @@ function createCodexAppServerForker(host) {
         if (error)
           reject(error);
         else if (result)
-          resolve6(result);
+          resolve7(result);
         else
           reject(new Error("Codex thread fork returned no result"));
       };
@@ -3148,8 +3309,8 @@ var init_codex_app_server = __esm(async () => {
 });
 
 // ../../packages/core/src/agents/codex-registry.ts
-import { existsSync as existsSync7, unlinkSync as unlinkSync7 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, unlinkSync as unlinkSync8 } from "fs";
+import { join as join9 } from "path";
 var VALID_EFFORTS2, codexRegistry, codexRegistryOperations;
 var init_codex_registry = __esm(async () => {
   init_logger();
@@ -3194,17 +3355,17 @@ var init_codex_registry = __esm(async () => {
     async cleanupRollouts({ sessionIds }) {
       if (sessionIds.length === 0)
         return;
-      const sessionsDir = join8(hostedCodexHomePath(), "sessions");
-      if (!existsSync7(sessionsDir))
+      const sessionsDir = join9(hostedCodexHomePath(), "sessions");
+      if (!existsSync8(sessionsDir))
         return;
       const failures = [];
       for (const tid of sessionIds) {
         try {
           const glob = new Bun.Glob(`**/rollout-*-${tid}.jsonl`);
           for await (const rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
-            const path = join8(sessionsDir, rel);
+            const path = join9(sessionsDir, rel);
             try {
-              unlinkSync7(path);
+              unlinkSync8(path);
             } catch (e) {
               if (e?.code !== "ENOENT") {
                 logger.warn({ err: e, path }, "codex cleanupRollouts: unlink failed");
@@ -3226,23 +3387,23 @@ var init_codex_registry = __esm(async () => {
 
 // ../../packages/core/src/agents/maestro-registry.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join9, resolve as resolve6 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join10, resolve as resolve7 } from "path";
 function maestroSessionsDir() {
-  return join9(process.env.MAESTRO_DATA_DIR ? resolve6(process.env.MAESTRO_DATA_DIR) : join9(homedir4(), ".maestro"), "sessions");
+  return join10(process.env.MAESTRO_DATA_DIR ? resolve7(process.env.MAESTRO_DATA_DIR) : join10(homedir5(), ".maestro"), "sessions");
 }
 function maestroSessionPath(sessionId) {
-  return join9(maestroSessionsDir(), `${sessionId}.jsonl`);
+  return join10(maestroSessionsDir(), `${sessionId}.jsonl`);
 }
 function maestroActiveSessionPath(sessionId) {
-  return join9(maestroSessionsDir(), `${sessionId}.active.jsonl`);
+  return join10(maestroSessionsDir(), `${sessionId}.active.jsonl`);
 }
 function existingCreatedAt(path) {
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return;
   try {
-    const firstLine = readFileSync7(path, "utf8").split(`
+    const firstLine = readFileSync8(path, "utf8").split(`
 `, 1)[0];
     const parsed = JSON.parse(firstLine);
     return typeof parsed._meta?.createdAt === "string" ? parsed._meta.createdAt : undefined;
@@ -3258,7 +3419,7 @@ function writeRollout(options) {
   assertUuidLike("sessionId", sessionId);
   ensureCwdExists(options.cwd);
   const path = maestroSessionPath(sessionId);
-  mkdirSync7(maestroSessionsDir(), { recursive: true });
+  mkdirSync8(maestroSessionsDir(), { recursive: true });
   const messages = extractChatPairs(options.entries).flatMap((pair) => [
     { role: "user", content: nonEmptyTurnText(pair.userText) },
     { role: "assistant", content: nonEmptyTurnText(pair.assistantText) }
@@ -3323,7 +3484,7 @@ var init_maestro_registry = __esm(() => {
       if (!parentMessages) {
         throw new Error(`Maestro parent session not found: ${options.parentSessionId}`);
       }
-      const parentHasActiveProjection = existsSync8(maestroActiveSessionPath(options.parentSessionId));
+      const parentHasActiveProjection = existsSync9(maestroActiveSessionPath(options.parentSessionId));
       const fork = forkSessionAt({
         parentSessionId: options.parentSessionId,
         messageIndex: parentMessages.length,
@@ -3338,7 +3499,7 @@ var init_maestro_registry = __esm(() => {
       return {
         forkId: fork.sessionId,
         rolloutPath: fork.rolloutPath,
-        ...existsSync8(activePath) ? { cleanupPaths: [activePath] } : {}
+        ...existsSync9(activePath) ? { cleanupPaths: [activePath] } : {}
       };
     },
     async cleanupRollouts(options) {
@@ -3350,7 +3511,7 @@ var init_maestro_registry = __esm(() => {
           const remaining = [
             maestroSessionPath(sessionId),
             maestroActiveSessionPath(sessionId)
-          ].filter(existsSync8);
+          ].filter(existsSync9);
           if (remaining.length > 0) {
             throw new Error(`Maestro session files remain after cleanup: ${remaining.join(", ")}`);
           }
@@ -3394,176 +3555,41 @@ var init_common = __esm(() => {
   init_mcp_helpers();
 });
 
-// ../../packages/core/src/storage/storage-host.ts
-import { mkdirSync as mkdirSync8 } from "fs";
-import { homedir as homedir5 } from "os";
-import { dirname as dirname7, join as join11, resolve as resolve7 } from "path";
-function envPath(name, fallback) {
-  const value2 = process.env[name]?.trim();
-  return resolve7(value2 || fallback);
-}
-function defaultStateDir() {
-  return envPath("NEGOTIUM_STATE_DIR", join11(homedir5(), ".negotium"));
-}
-function defaultDataDir() {
-  return envPath("NEGOTIUM_DATA_DIR", join11(defaultStateDir(), "data"));
-}
-function defaultLogDir() {
-  return envPath("NEGOTIUM_LOG_DIR", join11(defaultStateDir(), "logs"));
+// ../../packages/core/src/storage/forum-db.ts
+var db;
+var init_forum_db = __esm(async () => {
+  await init_storage_host();
+  db = internalStorageDatabase;
+});
+
+// ../../packages/core/src/storage/runtime-events.ts
+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 defaultWorkspaceDir() {
-  return envPath("NEGOTIUM_WORKSPACE_DIR", join11(defaultStateDir(), "workspace"));
+function latestRuntimeEventSeq() {
+  const row = db.query("SELECT MAX(seq) AS seq FROM runtime_events").get();
+  return Number(row?.seq ?? 0);
 }
-function defaultSessionAsksDir() {
-  const runDir = envPath("NEGOTIUM_RUN_DIR", join11(defaultStateDir(), "runtime"));
-  return join11(runDir, "session-asks");
-}
-function defaultSessionsDatabasePath() {
-  return envPath("SESSIONS_DB_PATH", join11(resolveStorageDataDir(), "sessions.db"));
-}
-function isSqliteBusy(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return /database is (?:locked|busy)|SQLITE_(?:BUSY|LOCKED)/i.test(message);
-}
-function execWithBusyRetry(database, sql, timeoutMs = SQLITE_INIT_TIMEOUT_MS) {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    try {
-      database.exec(sql);
-      return;
-    } catch (error) {
-      if (!isSqliteBusy(error) || Date.now() >= deadline)
-        throw error;
-      Atomics.wait(SQLITE_INIT_SLEEP, 0, 0, Math.min(SQLITE_INIT_RETRY_MS, deadline - Date.now()));
-    }
-  }
-}
-function initializeDatabase(database) {
-  database.exec("PRAGMA busy_timeout = 5000");
-  execWithBusyRetry(database, "PRAGMA journal_mode = WAL");
-  database.exec("PRAGMA foreign_keys = ON");
-  database.exec("PRAGMA wal_autocheckpoint = 1000");
-  try {
-    database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-  } catch {}
-}
-function defaultDatabase() {
-  const path = defaultSessionsDatabasePath();
-  if (fallbackDatabase && fallbackDatabasePath === path)
-    return fallbackDatabase;
-  if (fallbackDatabase)
-    fallbackDatabase.close();
-  mkdirSync8(dirname7(path), { recursive: true });
-  fallbackDatabase = new Database(path, { create: true });
-  fallbackDatabasePath = path;
-  initializeDatabase(fallbackDatabase);
-  return fallbackDatabase;
-}
-function resolveStorageDatabase() {
-  return configuredHost.database ?? defaultDatabase();
-}
-function resolveStorageDataDir() {
-  return configuredHost.dataDir ?? defaultDataDir();
-}
-function resolveStorageLogDir() {
-  return configuredHost.logDir ?? defaultLogDir();
-}
-function resolveStorageSessionAsksDir() {
-  return configuredHost.sessionAsksDir ?? defaultSessionAsksDir();
-}
-function resolveStorageWorkspaceDir() {
-  return configuredHost.workspaceDir ?? defaultWorkspaceDir();
-}
-function resolveStorageSharedWikiDir() {
-  return configuredHost.sharedWikiDir ?? join11(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;
-  let initialized = initializedSchemas.get(database);
-  if (!initialized) {
-    initialized = new Set;
-    initializedSchemas.set(database, initialized);
-  }
-  initializingDatabases.add(database);
-  try {
-    for (const entry of schemaInitializers) {
-      if (initialized.has(entry.initialize))
-        continue;
-      initialized.add(entry.initialize);
-      try {
-        entry.initialize(database);
-      } catch (error) {
-        initialized.delete(entry.initialize);
-        throw error;
-      }
-    }
-  } finally {
-    initializingDatabases.delete(database);
-  }
-}
-var configuredHost, fallbackDatabase = null, fallbackDatabasePath = null, schemaInitializers, initializedSchemas, initializingDatabases, SQLITE_INIT_RETRY_MS = 25, SQLITE_INIT_TIMEOUT_MS = 5000, SQLITE_INIT_SLEEP, internalStorageDatabase;
-var init_storage_host = __esm(async () => {
-  await init_sqlite();
-  configuredHost = {};
-  schemaInitializers = [];
-  initializedSchemas = new WeakMap;
-  initializingDatabases = new WeakSet;
-  SQLITE_INIT_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
-  internalStorageDatabase = new Proxy({}, {
-    get(_target, property) {
-      const database = resolveStorageDatabase();
-      ensureStorageSchemas(database);
-      const value2 = Reflect.get(database, property, database);
-      return typeof value2 === "function" ? value2.bind(database) : value2;
-    },
-    set(_target, property, value2) {
-      const database = resolveStorageDatabase();
-      ensureStorageSchemas(database);
-      return Reflect.set(database, property, value2, database);
-    }
-  });
-});
-
-// ../../packages/core/src/storage/forum-db.ts
-var db;
-var init_forum_db = __esm(async () => {
-  await init_storage_host();
-  db = internalStorageDatabase;
-});
-
-// ../../packages/core/src/storage/runtime-events.ts
-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 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
@@ -3575,7 +3601,10 @@ function listRuntimeEventsAfter(seq, limit = 500) {
 }
 var RUNTIME_EVENT_TYPES, types;
 var init_runtime_events = __esm(async () => {
-  await init_forum_db();
+  await __promiseAll([
+    init_forum_db(),
+    init_storage_host()
+  ]);
   RUNTIME_EVENT_TYPES = [
     "message",
     "message-updated",
@@ -3584,26 +3613,28 @@ var init_runtime_events = __esm(async () => {
     "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)");
+  registerStorageSchemaInitializer((database) => {
+    database.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
+    )
+  `);
+    database.exec("CREATE INDEX IF NOT EXISTS idx_runtime_events_topic_seq ON runtime_events(topic_id, seq)");
+  });
   types = new Set(RUNTIME_EVENT_TYPES);
 });
 
@@ -3763,13 +3794,17 @@ class SqliteRuntimeBus {
     };
   }
 }
-var current, WsHub;
+function runtimeBus() {
+  if (!current)
+    current = new SqliteRuntimeBus;
+  return current;
+}
+var current = null, WsHub;
 var init_bus = __esm(async () => {
   await init_runtime_events();
-  current = new SqliteRuntimeBus;
   WsHub = {
     get() {
-      return current;
+      return runtimeBus();
     }
   };
 });
@@ -5068,10 +5103,11 @@ var init_runtime_turn_requests = __esm(async () => {
   await __promiseAll([
     init_forum_db(),
     init_runtime_leases(),
-    init_runtime_topic_state()
+    init_runtime_topic_state(),
+    init_storage_host()
   ]);
   REQUEST_CLAIM_STALE_MS = TURN_LEASE_STALE_MS;
-  ensureRuntimeUserTurnRequestsSchema(db);
+  registerStorageSchemaInitializer((database) => ensureRuntimeUserTurnRequestsSchema(database));
 });
 
 // ../../packages/core/src/agents/registry.ts
@@ -5104,7 +5140,7 @@ var init_registry = __esm(async () => {
 });
 
 // ../../packages/core/src/agents/fork.ts
-import { existsSync as existsSync10, unlinkSync as unlinkSync8 } from "fs";
+import { existsSync as existsSync11, unlinkSync as unlinkSync9 } from "fs";
 function createAgentForkHelpers(host) {
   return {
     async forkAgentSession(options) {
@@ -5141,8 +5177,8 @@ var init_fork = __esm(async () => {
   await init_registry();
   defaultForkHelpers = createAgentForkHelpers({
     forkSession: (agent, options) => getRegistryOperations(agent).forkSession(options),
-    exists: existsSync10,
-    unlink: unlinkSync8,
+    exists: existsSync11,
+    unlink: unlinkSync9,
     warn: (details, message) => logger.warn(details, message)
   });
 });
@@ -5541,7 +5577,7 @@ var init_runtime_process_leases = __esm(async () => {
 
 // ../../packages/core/src/platform/playwright/browser-processes.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readdirSync as readdirSync4, unlinkSync as unlinkSync9 } from "fs";
+import { readdirSync as readdirSync4, unlinkSync as unlinkSync10 } from "fs";
 import { createServer } from "net";
 import { resolve as resolve8, sep } from "path";
 function isPortInUse(port) {
@@ -5670,7 +5706,7 @@ function cleanSingletonFiles(userDataDir) {
     for (const f of files) {
       if (f.startsWith("Singleton")) {
         try {
-          unlinkSync9(resolve8(userDataDir, f));
+          unlinkSync10(resolve8(userDataDir, f));
           logger.info({ file: f, userDataDir }, "Removed stale Singleton file");
         } catch (e) {
           logger.warn({ err: e, file: f }, "Failed to remove stale Chrome Singleton file");
@@ -5811,7 +5847,7 @@ var init_vault_public = __esm(async () => {
 
 // ../../packages/core/src/platform/playwright/vault-broker.ts
 import { randomBytes as randomBytes5, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { chmodSync as chmodSync4 } from "fs";
+import { chmodSync as chmodSync5 } from "fs";
 import { createServer as createServer2 } from "net";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join12 } from "path";
@@ -6007,7 +6043,7 @@ async function createBrowserVaultBroker(userId) {
     server.once("error", reject);
     server.listen(socketPath, resolveListen);
   });
-  chmodSync4(socketPath, 384);
+  chmodSync5(socketPath, 384);
   let closed = false;
   return {
     socketPath,
@@ -6099,15 +6135,20 @@ function assignTopicBrowserProfile(opts) {
 }
 var DEFAULT_BROWSER_PROFILE = "default";
 var init_browser_profiles = __esm(async () => {
-  await init_forum_db();
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS browser_profiles (
-    owner_id TEXT NOT NULL,
-    name TEXT NOT NULL,
-    created_at TEXT NOT NULL,
-    PRIMARY KEY (owner_id, name)
-  )
-`);
+  await __promiseAll([
+    init_forum_db(),
+    init_storage_host()
+  ]);
+  registerStorageSchemaInitializer((database) => {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS browser_profiles (
+      owner_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (owner_id, name)
+    )
+  `);
+  });
 });
 
 // ../../packages/core/src/platform/playwright/manager.ts
@@ -6115,11 +6156,11 @@ import { execFileSync as execFileSync4, spawn as spawn6 } from "child_process";
 import { createHash as createHash3, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual3 } from "crypto";
 import {
   cpSync,
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   rmSync as rmSync2,
-  unlinkSync as unlinkSync10,
+  unlinkSync as unlinkSync11,
   writeFileSync as writeFileSync7
 } from "fs";
 import { dirname as dirname8, join as join13, resolve as resolve10 } from "path";
@@ -6129,7 +6170,7 @@ function removeDefaultProfileDataDir(userDataDir) {
   if (dirname8(target) !== root) {
     throw new Error(`Refusing to delete browser profile outside managed root: ${target}`);
   }
-  const existed = existsSync11(target);
+  const existed = existsSync12(target);
   rmSync2(target, { recursive: true, force: true });
   return existed;
 }
@@ -6219,7 +6260,7 @@ function writePortFile(instanceKey, port) {
 }
 function deletePortFile(instanceKey) {
   try {
-    unlinkSync10(join13(managerHost.portsDir, portFileName(instanceKey)));
+    unlinkSync11(join13(managerHost.portsDir, portFileName(instanceKey)));
   } catch (e) {
     if (e.code === "ENOENT")
       return;
@@ -6704,11 +6745,11 @@ async function cloneProfileForChild(opts) {
       killInstance(dstKey);
       await delay(500);
     }
-    if (!existsSync11(srcDir)) {
+    if (!existsSync12(srcDir)) {
       return { copied: false, srcDir, dstDir, reason: "src-missing" };
     }
     try {
-      if (existsSync11(dstDir)) {
+      if (existsSync12(dstDir)) {
         rmSync2(dstDir, { recursive: true, force: true });
       }
       mkdirSync9(dirname8(dstDir), { recursive: true });
@@ -6729,7 +6770,7 @@ async function cloneProfileForChild(opts) {
     cleanSingletonFiles(dstDir);
     for (const f of ["DevToolsActivePort", "LOCK"]) {
       try {
-        unlinkSync10(resolve10(dstDir, f));
+        unlinkSync11(resolve10(dstDir, f));
       } catch {}
     }
     logger.info({ srcKey, dstKey, srcDir, dstDir }, "Cloned Playwright profile for child topic");
@@ -7277,11 +7318,11 @@ var init_api_topic_config = __esm(async () => {
 
 // ../../packages/core/src/storage/conversations.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync as renameSync5,
-  unlinkSync as unlinkSync11,
+  unlinkSync as unlinkSync12,
   writeFileSync as writeFileSync8
 } from "fs";
 import { dirname as dirname9, join as join14 } from "path";
@@ -7300,7 +7341,7 @@ function getActiveConversationPath(userId, topicName) {
   return rawPath.endsWith(".jsonl") ? `${rawPath.slice(0, -".jsonl".length)}.active.jsonl` : `${rawPath}.active`;
 }
 function hasActiveConversation(userId, topicName) {
-  return existsSync12(getActiveConversationPath(userId, topicName));
+  return existsSync13(getActiveConversationPath(userId, topicName));
 }
 function appendConversationEvent(userId, topicName, agent, event) {
   try {
@@ -7322,7 +7363,7 @@ function appendConversationEventStrict(userId, topicName, agent, event) {
   mkdirSync10(dirname9(path), { recursive: true });
   appendJsonlLine(path, line);
   const activePath = getActiveConversationPath(userId, topicName);
-  if (existsSync12(activePath)) {
+  if (existsSync13(activePath)) {
     try {
       appendJsonlLine(activePath, line);
     } catch (cause) {
@@ -7332,11 +7373,11 @@ function appendConversationEventStrict(userId, topicName, agent, event) {
 }
 function readConversationPath(path) {
   const out = [];
-  if (!existsSync12(path))
+  if (!existsSync13(path))
     return out;
   let raw;
   try {
-    raw = readFileSync10(path, "utf8");
+    raw = readFileSync11(path, "utf8");
   } catch (err) {
     logger.warn({ err, path }, "readConversation: read failed");
     return out;
@@ -7355,7 +7396,7 @@ function readConversationPath(path) {
 }
 function readConversation(userId, topicName) {
   const activePath = getActiveConversationPath(userId, topicName);
-  return readConversationPath(existsSync12(activePath) ? activePath : getConversationPath(userId, topicName));
+  return readConversationPath(existsSync13(activePath) ? activePath : getConversationPath(userId, topicName));
 }
 function readRawConversation(userId, topicName) {
   return readConversationPath(getConversationPath(userId, topicName));
@@ -7376,7 +7417,7 @@ function replaceConversationPathStrict(path, entries) {
     renameSync5(tempPath, path);
   } catch (error) {
     try {
-      unlinkSync11(tempPath);
+      unlinkSync12(tempPath);
     } catch {}
     throw error;
   }
@@ -7513,7 +7554,7 @@ RULES:
 - Keep the entire summary under 1500 words.`, CHARS_PER_TEXT_TOKEN = 3.5, CHARS_PER_CJK_TOKEN = 0.9;
 
 // ../../packages/core/src/storage/tasks.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync11, renameSync as renameSync6, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync12, renameSync as renameSync6, statSync as statSync4, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname10, join as join15 } from "path";
 function safeTaskScopeKey(scopeKey) {
   const safe = sanitizeFileName(scopeKey);
@@ -7530,10 +7571,10 @@ function getTaskFilePath(userId, scopeKey) {
 }
 function readTasks(userId, scopeKey) {
   const path = getTaskFilePath(userId, scopeKey);
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return [];
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync12(path, "utf-8"));
     return Array.isArray(parsed?.tasks) ? parsed.tasks : [];
   } catch (e) {
     logger.warn({ err: e, path }, "tasks: failed to read task store");
@@ -7788,7 +7829,7 @@ __export(exports_claude_provider, {
   buildClaudeDisallowedTools: () => buildClaudeDisallowedTools
 });
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 function claudeBuiltInTools(opts) {
   return opts.toolPolicy ? [] : undefined;
@@ -7841,7 +7882,7 @@ function buildClaudePrompt(opts) {
         source: {
           type: "base64",
           media_type: attachment.mimeType,
-          data: readFileSync12(attachment.path).toString("base64")
+          data: readFileSync13(attachment.path).toString("base64")
         }
       });
     } catch (err) {
@@ -7969,7 +8010,7 @@ function isAbortError(err) {
 }
 async function* claudeProvider(opts) {
   const claudeExecutable = hostedClaudeCodeExecutablePath();
-  if (claudeExecutable && !existsSync14(claudeExecutable)) {
+  if (claudeExecutable && !existsSync15(claudeExecutable)) {
     yield {
       type: "error",
       content: `Claude CLI not found at ${claudeExecutable}. Install Claude Code or configure the executable path.`
@@ -8489,7 +8530,7 @@ var init_codex_tree_kill = __esm(() => {
 });
 
 // ../../packages/core/src/agents/tool-format.ts
-import { readFileSync as readFileSync13, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync14, statSync as statSync5 } from "fs";
 import { isAbsolute as isAbsolute2, resolve as resolve11 } from "path";
 import { diffLines as computeLineDiff } from "diff";
 function summarizeDisplayText(value2) {
@@ -8818,7 +8859,7 @@ function sourceStartLine(input, before, after, cwd) {
   try {
     if (statSync5(path).size > TOOL_DIFF_SOURCE_MAX_BYTES)
       return 1;
-    const source = readFileSync13(path, "utf8").replace(/\r\n?/g, `
+    const source = readFileSync14(path, "utf8").replace(/\r\n?/g, `
 `);
     for (const candidate of [before, after].filter(Boolean)) {
       const index = source.indexOf(candidate);
@@ -9012,7 +9053,7 @@ __export(exports_codex_provider, {
   codexProvider: () => codexProvider
 });
 import { execFileSync as execFileSync6 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync14, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync15, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname11, isAbsolute as isAbsolute3, join as join16, relative as relative2, resolve as resolve12 } from "path";
 import { Codex } from "@openai/codex-sdk";
@@ -9043,11 +9084,11 @@ function codexMcpServerName(name) {
 }
 function globalCodexMcpServerNames(authFilePath) {
   const configPath = join16(dirname11(authFilePath), "config.toml");
-  if (!existsSync15(configPath))
+  if (!existsSync16(configPath))
     return [];
   try {
     const names = new Set;
-    for (const line of readFileSync14(configPath, "utf8").split(`
+    for (const line of readFileSync15(configPath, "utf8").split(`
 `)) {
       const match = line.match(/^\s*\[\s*mcp_servers\.((?:"(?:\\.|[^"])*")|(?:'[^']*')|[^.\]\s]+)(?:[.\]])/);
       const raw = match?.[1];
@@ -9144,13 +9185,13 @@ function canonicalPath(path) {
   }
 }
 function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     return null;
   try {
     const byteLimit = Math.min(CODEX_DIFF_FILE_LIMIT, Math.max(0, maxBytes));
     if (statSync6(path).size > byteLimit)
       return;
-    const content = readFileSync14(path);
+    const content = readFileSync15(path);
     if (content.byteLength > byteLimit || content.includes(0))
       return;
     return content.toString("utf8");
@@ -9356,7 +9397,7 @@ async function* codexProvider(opts) {
   const filePreviews = new CodexFilePreviewTracker(opts.cwd);
   const consumedPatchCallIds = new Set(opts.sessionId ? readCodexPatchCallIds(opts.sessionId) : []);
   const codexAuthPath = hostedCodexAuthFilePath();
-  if (!existsSync15(codexAuthPath)) {
+  if (!existsSync16(codexAuthPath)) {
     yield {
       type: "error",
       content: `Codex auth file not found at ${codexAuthPath}. Run \`codex login\` to authenticate.`
@@ -9395,7 +9436,7 @@ async function* codexProvider(opts) {
     model: opts.model ?? "(sdk default)",
     effort: opts.effort ?? "(off)",
     cwd: opts.cwd,
-    cwdExists: existsSync15(opts.cwd),
+    cwdExists: existsSync16(opts.cwd),
     resume: Boolean(opts.sessionId),
     mcpServerCount: Object.keys(codexMcpServers).length
   }, "codexProvider: starting turn");
@@ -9847,7 +9888,7 @@ var init_maestro_provider = __esm(async () => {
 });
 
 // ../../packages/core/src/agents/index.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join17 } from "path";
 async function* dispatchAgent(opts) {
@@ -9884,7 +9925,7 @@ async function resolveSessionFileMissing(agent, sessionId, cwd) {
     case "claude": {
       const encodedCwd = encodeClaudeCwd(cwd);
       const path = join17(homedir7(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
-      return !existsSync16(path);
+      return !existsSync17(path);
     }
     case "codex": {
       const sessionsDir = join17(hostedCodexHomePath(), "sessions");
@@ -9896,7 +9937,7 @@ async function resolveSessionFileMissing(agent, sessionId, cwd) {
     }
     case "maestro": {
       const { hasActiveMaestroSession, maestroSessionPath: maestroSessionPath2 } = await import("maestro-agent-sdk");
-      return !existsSync16(maestroSessionPath2(sessionId)) && !hasActiveMaestroSession(sessionId);
+      return !existsSync17(maestroSessionPath2(sessionId)) && !hasActiveMaestroSession(sessionId);
     }
     default: {
       const _exhaustive = agent;
@@ -9969,10 +10010,10 @@ var init_agents = __esm(async () => {
 });
 
 // ../../packages/core/src/prompts/builders.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { resolve as resolve14 } from "path";
 function loadPrompt(filename, dir = SESSIONS_DIR) {
-  const raw = readFileSync15(resolve14(dir, filename), "utf-8");
+  const raw = readFileSync16(resolve14(dir, filename), "utf-8");
   return raw.replace(/\{\{RESOURCES_DIR\}\}/g, RESOURCES_DIR);
 }
 function replaceVars(template, vars) {
@@ -10021,7 +10062,7 @@ function visualDesignGuide() {
   return _visualDesignGuide;
 }
 function loadAgentPrompt(filename) {
-  const raw = readFileSync15(resolve14(AGENTS_PROMPTS_DIR, filename), "utf-8");
+  const raw = readFileSync16(resolve14(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`);
@@ -10420,7 +10461,7 @@ var init_wiki = __esm(async () => {
 
 // ../../packages/core/src/agents/archiver.ts
 import { randomUUID as randomUUID9 } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync16, statSync as statSync7 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync5, readFileSync as readFileSync17, statSync as statSync7 } from "fs";
 import { join as join19 } from "path";
 function resolveMemoryLanguage() {
   const override = process.env.NEGOTIUM_MEMORY_LANG?.trim();
@@ -10440,9 +10481,9 @@ function formatArchiverBytes(bytes) {
 function formatArchiverTool(name, input) {
   const params = Object.entries(input).map(([key, value2]) => {
     const rendered = typeof value2 === "string" ? value2 : JSON.stringify(value2);
-    return `${key}: ${sessionText(rendered ?? "")}`;
+    return `${key}: ${summarizeDisplayText(sessionText(rendered ?? ""))}`;
   }).join(", ");
-  return `${name}${params ? `(${params})` : ""}`;
+  return summarizeDisplayText(`${name}${params ? `(${params})` : ""}`);
 }
 function createArchiverRuntime(host) {
   const activeSessions = new Map;
@@ -10749,6 +10790,7 @@ function runArchiverTurn(params) {
 }
 var MAX_BRIEF_ENTRIES = 8, defaultArchiverRuntime;
 var init_archiver = __esm(async () => {
+  init_tool_format();
   init_config();
   init_logger();
   init_builders();
@@ -10765,9 +10807,9 @@ var init_archiver = __esm(async () => {
   defaultArchiverRuntime = createArchiverRuntime({
     storage: {
       getWikiDir: getSharedWikiDir,
-      fileExists: existsSync17,
+      fileExists: existsSync18,
       listDirectory: readdirSync5,
-      readTextFile: (path) => readFileSync16(path, "utf-8"),
+      readTextFile: (path) => readFileSync17(path, "utf-8"),
       fileSize: (path) => statSync7(path).size,
       fileModifiedAt: (path) => statSync7(path).mtimeMs,
       getGeneralTopicId: (userId) => ensurePersonalGeneral(userId).id,
@@ -11304,7 +11346,7 @@ var init_idle_archiver = __esm(async () => {
 });
 
 // ../../packages/core/src/agents/topic-cleanup.ts
-import { mkdirSync as mkdirSync13, renameSync as renameSync7, unlinkSync as unlinkSync12, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync13, renameSync as renameSync7, unlinkSync as unlinkSync13, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname13 } from "path";
 function collectSessionIdsByAgent(entries, extraSessions = []) {
   const out = new Map;
@@ -11378,7 +11420,7 @@ function createTopicLogMaintenance(host) {
         renameSync7(tempPath, path);
       } catch (e) {
         try {
-          unlinkSync12(tempPath);
+          unlinkSync13(tempPath);
         } catch {}
         runtimeHost.warn({ err: e, path }, "rotateTopicLogs: conversation replacement failed");
         return {
@@ -11408,7 +11450,7 @@ function createTopicLogMaintenance(host) {
         runtimeHost.rawConversationPath(userId, topicName)
       ]) {
         try {
-          unlinkSync12(path);
+          unlinkSync13(path);
         } catch (e) {
           if (e?.code !== "ENOENT") {
             runtimeHost.warn({ err: e, path }, "purgeTopicLogs: conversation log unlink failed");
@@ -11510,6 +11552,7 @@ function text(value2, maxLen) {
 }
 var providers, transientSessions;
 var init_background_sessions = __esm(async () => {
+  init_tool_format();
   init_background_session_policy();
   await __promiseAll([
     init_archiver(),
@@ -11960,7 +12003,7 @@ __export(exports_derive, {
   TopicDeriveBusyError: () => TopicDeriveBusyError
 });
 import { createHash as createHash4, randomUUID as randomUUID11 } from "crypto";
-import { mkdirSync as mkdirSync14, rmSync as rmSync5, unlinkSync as unlinkSync13 } from "fs";
+import { mkdirSync as mkdirSync14, rmSync as rmSync5, unlinkSync as unlinkSync14 } from "fs";
 function getTopics() {
   return listTopics().filter((topic) => !isLegacySharedGeneral(topic.id));
 }
@@ -12255,7 +12298,7 @@ async function createDerivedTopicImpl(topic, sourceTopicId, userId, copyHistory,
         getConversationPath(userId, derived.title)
       ]) {
         try {
-          unlinkSync13(path);
+          unlinkSync14(path);
         } catch {}
       }
     }
@@ -12327,7 +12370,7 @@ var init_session_inbox_path = __esm(() => {
 });
 
 // ../../packages/core/src/query/session-inbox-cleanup.ts
-import { unlinkSync as unlinkSync14 } from "fs";
+import { unlinkSync as unlinkSync15 } from "fs";
 import { basename as basename4, join as join23 } from "path";
 function cleanupSessionInboxFiles(userId, topicId, legacyTopicTitle) {
   const live = sessionInboxPath(userId, topicId);
@@ -12342,7 +12385,7 @@ function cleanupSessionInboxFiles(userId, topicId, legacyTopicTitle) {
   let deleted = 0;
   for (const path of candidates) {
     try {
-      unlinkSync14(path);
+      unlinkSync15(path);
       deleted++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
@@ -12359,7 +12402,7 @@ var init_session_inbox_cleanup = __esm(() => {
 });
 
 // ../../packages/core/src/query/state.ts
-import { mkdirSync as mkdirSync15, renameSync as renameSync8, unlinkSync as unlinkSync15, writeFileSync as writeFileSync13 } from "fs";
+import { mkdirSync as mkdirSync15, renameSync as renameSync8, unlinkSync as unlinkSync16, writeFileSync as writeFileSync13 } from "fs";
 import { basename as basename5, join as join24 } from "path";
 function createQueryStateStore(options) {
   const sanitize = options.sanitizeTopicId ?? sanitizeId;
@@ -12390,7 +12433,7 @@ function createQueryStateStore(options) {
       ].filter((path) => Boolean(path));
       for (const path of new Set(paths)) {
         try {
-          unlinkSync15(path);
+          unlinkSync16(path);
         } catch (error) {
           if (error?.code !== "ENOENT") {
             options.logger?.warn({ err: error, userId, topicId, path }, "Failed to clear query state file");
@@ -12524,9 +12567,9 @@ import {
   mkdirSync as mkdirSync16,
   openSync as openSync3,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   statSync as statSync8,
-  unlinkSync as unlinkSync16,
+  unlinkSync as unlinkSync17,
   writeFileSync as writeFileSync14
 } from "fs";
 import { dirname as dirname14, join as join25 } from "path";
@@ -12573,7 +12616,7 @@ function parsePendingAskFilename(fileName) {
 }
 function readPendingAskFile(path, fallback) {
   try {
-    const raw = readFileSync17(path, "utf8").trim();
+    const raw = readFileSync18(path, "utf8").trim();
     if (!raw)
       return null;
     if (!raw.startsWith("{")) {
@@ -12662,7 +12705,7 @@ function readPendingAsk(key) {
     const next = migrated ? legacy : readPendingAskFile(canonicalPath2, key);
     if (next && next.from === key.from && next.to === key.to) {
       try {
-        unlinkSync16(compatibilityPath);
+        unlinkSync17(compatibilityPath);
       } catch {}
       return { path: canonicalPath2, record: next };
     }
@@ -12677,7 +12720,7 @@ function createPendingAsk(args) {
   }
   if (migrated) {
     try {
-      unlinkSync16(migrated.path);
+      unlinkSync17(migrated.path);
     } catch {
       return { ok: false, existing: migrated.record, stale: true };
     }
@@ -12709,7 +12752,7 @@ function createPendingAsk(args) {
       if (!isStale(existing, path))
         return { ok: false, existing, stale: false };
       try {
-        unlinkSync16(path);
+        unlinkSync17(path);
       } catch {
         return { ok: false, existing, stale: true };
       }
@@ -12735,7 +12778,7 @@ function markPendingAskState(args) {
   writePendingAsk(next);
   if (pending.path !== pendingAskPath(next)) {
     try {
-      unlinkSync16(pending.path);
+      unlinkSync17(pending.path);
     } catch {}
   }
   return next;
@@ -12747,7 +12790,7 @@ function clearPendingAsk(args) {
   if (args.requestId && record && record.requestId !== args.requestId)
     return false;
   try {
-    unlinkSync16(path);
+    unlinkSync17(path);
     return true;
   } catch {
     return false;
@@ -12802,7 +12845,7 @@ function listPendingAsksForCaller(args) {
       continue;
     if (isStale(record, path)) {
       try {
-        unlinkSync16(path);
+        unlinkSync17(path);
       } catch {}
       continue;
     }
@@ -12811,12 +12854,12 @@ function listPendingAsksForCaller(args) {
       continue;
     if (path !== canonical.path) {
       try {
-        unlinkSync16(path);
+        unlinkSync17(path);
       } catch {}
     }
     if (isStale(canonical.record, canonical.path)) {
       try {
-        unlinkSync16(canonical.path);
+        unlinkSync17(canonical.path);
       } catch {}
       continue;
     }
@@ -12846,7 +12889,7 @@ function deletePendingAsksForTopic(args) {
     if (from !== args.topicName && to !== args.topicName)
       continue;
     try {
-      unlinkSync16(path);
+      unlinkSync17(path);
       deleted++;
     } catch {}
   }
@@ -12947,19 +12990,22 @@ var pendingAsks, MAX_ASK_AGE_MS;
 var init_ask_callbacks = __esm(async () => {
   await __promiseAll([
     init_forum_db(),
-    init_session_asks()
+    init_session_asks(),
+    init_storage_host()
   ]);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS remote_ask_callbacks (
-    target_query_id TEXT PRIMARY KEY,
-    request_id TEXT NOT NULL,
-    node_name TEXT NOT NULL,
-    node_cell_id TEXT NOT NULL,
-    topic_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    created_at INTEGER NOT NULL
-  )
-`);
+  registerStorageSchemaInitializer((database) => {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS remote_ask_callbacks (
+      target_query_id TEXT PRIMARY KEY,
+      request_id TEXT NOT NULL,
+      node_name TEXT NOT NULL,
+      node_cell_id TEXT NOT NULL,
+      topic_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+  });
   pendingAsks = new Map;
   MAX_ASK_AGE_MS = PENDING_ASK_TTL_MS;
 });
@@ -13172,30 +13218,35 @@ paint();document.body.appendChild(b)}
 if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",init);else init()})();
 </script>`;
 var init_visual_store = __esm(async () => {
-  await init_forum_db();
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS api_topic_visuals (
-    id         INTEGER PRIMARY KEY AUTOINCREMENT,
-    topic_id   TEXT    NOT NULL,
-    html       TEXT    NOT NULL,
-    title      TEXT,
-    created_at INTEGER NOT NULL,
-    kind       TEXT    NOT NULL DEFAULT 'html',
-    source     TEXT,
-    file_id    TEXT,
-    mime_type  TEXT,
-    media_token TEXT
-  );
-  CREATE INDEX IF NOT EXISTS idx_api_topic_visuals_topic
-    ON api_topic_visuals(topic_id, created_at DESC);
-
-  CREATE TABLE IF NOT EXISTS api_topic_visual_views (
-    topic_id  TEXT NOT NULL,
-    user_id   TEXT NOT NULL,
-    visual_id INTEGER NOT NULL,
-    PRIMARY KEY (topic_id, user_id)
-  );
-`);
+  await __promiseAll([
+    init_forum_db(),
+    init_storage_host()
+  ]);
+  registerStorageSchemaInitializer((database) => {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS api_topic_visuals (
+      id         INTEGER PRIMARY KEY AUTOINCREMENT,
+      topic_id   TEXT    NOT NULL,
+      html       TEXT    NOT NULL,
+      title      TEXT,
+      created_at INTEGER NOT NULL,
+      kind       TEXT    NOT NULL DEFAULT 'html',
+      source     TEXT,
+      file_id    TEXT,
+      mime_type  TEXT,
+      media_token TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_api_topic_visuals_topic
+      ON api_topic_visuals(topic_id, created_at DESC);
+  
+    CREATE TABLE IF NOT EXISTS api_topic_visual_views (
+      topic_id  TEXT NOT NULL,
+      user_id   TEXT NOT NULL,
+      visual_id INTEGER NOT NULL,
+      PRIMARY KEY (topic_id, user_id)
+    );
+  `);
+  });
   for (const statement of [
     "ALTER TABLE api_topic_visuals ADD COLUMN kind TEXT NOT NULL DEFAULT 'html'",
     "ALTER TABLE api_topic_visuals ADD COLUMN source TEXT",
@@ -13236,32 +13287,35 @@ var init_self_schedules = __esm(async () => {
   await __promiseAll([
     init_forum_db(),
     init_runtime_leases(),
-    init_runtime_topic_state()
+    init_runtime_topic_state(),
+    init_storage_host()
   ]);
-  db.exec(`
-  CREATE TABLE IF NOT EXISTS runtime_self_schedules (
-    id TEXT PRIMARY KEY,
-    topic_id TEXT NOT NULL,
-    user_id TEXT NOT NULL,
-    message TEXT NOT NULL,
-    deliver_at INTEGER NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL,
-    status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running')),
-    claimed_by TEXT,
-    claimed_at INTEGER,
-    running_query_id TEXT
-  )
-`);
-  db.exec(`
-  CREATE UNIQUE INDEX IF NOT EXISTS idx_runtime_self_schedules_one_pending
-  ON runtime_self_schedules(topic_id)
-  WHERE status = 'pending'
-`);
-  db.exec(`
-  CREATE INDEX IF NOT EXISTS idx_runtime_self_schedules_due
-  ON runtime_self_schedules(status, deliver_at)
-`);
+  registerStorageSchemaInitializer((database) => {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS runtime_self_schedules (
+      id TEXT PRIMARY KEY,
+      topic_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      message TEXT NOT NULL,
+      deliver_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running')),
+      claimed_by TEXT,
+      claimed_at INTEGER,
+      running_query_id TEXT
+    )
+  `);
+    database.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_runtime_self_schedules_one_pending
+    ON runtime_self_schedules(topic_id)
+    WHERE status = 'pending'
+  `);
+    database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_runtime_self_schedules_due
+    ON runtime_self_schedules(status, deliver_at)
+  `);
+  });
 });
 
 // ../../packages/core/src/topics/lifecycle.ts
@@ -15506,7 +15560,7 @@ var init_turn_session = __esm(async () => {
 });
 
 // ../../packages/core/src/storage/app-settings.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync19, readFileSync as readFileSync19, writeFileSync as writeFileSync16 } from "fs";
 import { dirname as dirname15, join as join28 } from "path";
 function settingsFile() {
   return join28(resolveStorageDataDir(), "otium-settings.json");
@@ -15518,8 +15572,8 @@ function ensureSettingsLoaded() {
   loadedSettingsFile = path;
   aiName = DEFAULT_AI_NAME;
   try {
-    if (existsSync18(path)) {
-      const data = JSON.parse(readFileSync18(path, "utf8"));
+    if (existsSync19(path)) {
+      const data = JSON.parse(readFileSync19(path, "utf8"));
       if (typeof data.aiName === "string" && data.aiName.trim()) {
         aiName = data.aiName.trim();
       }
@@ -15612,7 +15666,7 @@ __export(exports_turn_runner, {
   AGENT_DISPLAY_NAME: () => AGENT_DISPLAY_NAME
 });
 import { randomUUID as randomUUID16 } from "crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync20, readdirSync as readdirSync7, statSync as statSync10 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync20, readdirSync as readdirSync7, statSync as statSync10 } from "fs";
 import { join as join29 } from "path";
 function withDefaultPlaywright(configuredMcp, isManager) {
   if (isManager)
@@ -15669,7 +15723,7 @@ function appendAskReplyMessage(topicId, text2, agentType) {
 }
 function resolveWikiMirrorPath(directory, preferredFilename, matchesLegacyId, matchesTitle, preferExact = true) {
   const preferred = join29(directory, preferredFilename);
-  if (preferExact && existsSync19(preferred))
+  if (preferExact && existsSync20(preferred))
     return preferred;
   let newestLegacyId = null;
   let newestTitle = null;
@@ -15694,9 +15748,9 @@ function resolveWikiMirrorPath(directory, preferredFilename, matchesLegacyId, ma
 }
 function resolveWikiMemoryMirror(wikiDir, topicId, topicTitle) {
   const briefFile = resolveWikiMirrorPath(join29(wikiDir, "topic"), `${wikiBriefStorageKey(topicTitle, topicId)}.md`, (filename) => isTopicBriefFile(filename, topicId), (filename) => isTopicBriefFile(filename, topicId, topicTitle));
-  const hasBriefFile = existsSync19(briefFile) && statSync10(briefFile).isFile();
+  const hasBriefFile = existsSync20(briefFile) && statSync10(briefFile).isFile();
   const latestSummaryCandidate = resolveWikiMirrorPath(join29(wikiDir, "summaries"), `__missing__-${wikiSummaryFilename("0000-00-00", topicTitle, topicId)}`, (filename) => isTopicSummaryFile(filename, topicId), (filename) => isTopicSummaryFile(filename, topicId, topicTitle), false);
-  const latestSummaryFile = existsSync19(latestSummaryCandidate) && statSync10(latestSummaryCandidate).isFile() ? latestSummaryCandidate : null;
+  const latestSummaryFile = existsSync20(latestSummaryCandidate) && statSync10(latestSummaryCandidate).isFile() ? latestSummaryCandidate : null;
   return { briefFile, hasBriefFile, latestSummaryFile };
 }
 async function streamAgentEvents(topicId, topicTitle, queryId, events, control, agentType, model, effort, userId, retryableSessionExpired = true, onSessionId, execution) {
@@ -16892,7 +16946,7 @@ __export(exports_auth_check, {
   checkAgentAuth: () => checkAgentAuth
 });
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { homedir as homedir8, platform } from "os";
 import { join as join30 } from "path";
 function hasMaestroCredential(host, key, userId) {
@@ -16965,7 +17019,7 @@ var init_auth_check = __esm(async () => {
   await init_vault();
   defaultAgentAuthHost = {
     codexAuthFilePath,
-    exists: existsSync20,
+    exists: existsSync21,
     environment: process.env,
     homeDirectory: homedir8,
     operatingSystem: platform,
@@ -18196,25 +18250,238 @@ import { AsyncLocalStorage } from "async_hooks";
 import { randomUUID } from "crypto";
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   openSync,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
   statSync,
-  unlinkSync,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2
 } from "fs";
 import { basename, dirname as dirname2, join as join2, relative, resolve as resolve2 } from "path";
-init_config();
-init_wiki_summary_names();
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
+
+// ../../packages/core/src/mcp/wiki-search-index.ts
+await init_sqlite();
+import { chmodSync, existsSync, readFileSync, unlinkSync } from "fs";
+var SEARCH_INDEX_SCHEMA_VERSION = 3;
+function documentId(source) {
+  return `${source.kind}:${source.key}`;
+}
+function ensureSchema(database) {
+  const version = database.query("PRAGMA user_version").get()?.user_version;
+  if (version !== 0 && version !== SEARCH_INDEX_SCHEMA_VERSION) {
+    throw new Error(`Unsupported wiki search index schema: ${version}`);
+  }
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS wiki_search_documents (
+      id TEXT PRIMARY KEY,
+      kind TEXT NOT NULL,
+      key TEXT NOT NULL,
+      path TEXT NOT NULL,
+      mtime_ms REAL NOT NULL,
+      size INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      text TEXT NOT NULL,
+      date TEXT,
+      family TEXT
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS wiki_search_documents_kind_key
+      ON wiki_search_documents(kind, key);
+    CREATE INDEX IF NOT EXISTS wiki_search_documents_kind_date
+      ON wiki_search_documents(kind, date);
+    CREATE INDEX IF NOT EXISTS wiki_search_documents_kind_family_date
+      ON wiki_search_documents(kind, family, date);
+    CREATE VIRTUAL TABLE IF NOT EXISTS wiki_search_fts USING fts5(
+      document_id UNINDEXED,
+      kind UNINDEXED,
+      tokens,
+      tokenize = 'unicode61'
+    );
+    PRAGMA user_version = ${SEARCH_INDEX_SCHEMA_VERSION};
+  `);
+}
+
+class WikiSearchIndex {
+  path;
+  #database;
+  constructor(path) {
+    this.path = path;
+    this.#database = new Database(path, { create: true });
+    try {
+      this.#database.exec("PRAGMA foreign_keys = ON; PRAGMA journal_mode = DELETE;");
+      ensureSchema(this.#database);
+      chmodSync(path, 384);
+    } catch (error) {
+      this.#database.close();
+      throw error;
+    }
+  }
+  close() {
+    this.#database.close();
+  }
+  upsert(source, document) {
+    const id = documentId(source);
+    const apply = this.#database.transaction(() => {
+      this.#database.query("DELETE FROM wiki_search_fts WHERE document_id = ?").run(id);
+      this.#database.query("DELETE FROM wiki_search_documents WHERE id = ?").run(id);
+      this.#database.query(`
+          INSERT INTO wiki_search_documents
+            (id, kind, key, path, mtime_ms, size, title, text, date, family)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(id, source.kind, source.key, source.path, source.mtimeMs, source.size, document.title, document.text, document.date ?? null, document.family ?? null);
+      this.#database.query("INSERT INTO wiki_search_fts(document_id, kind, tokens) VALUES (?, ?, ?)").run(id, source.kind, document.tokens.join(" "));
+    });
+    apply.immediate();
+  }
+  sync(sources, prepare) {
+    const result = { added: 0, updated: 0, removed: 0 };
+    const existingRows = this.#database.query("SELECT id, path, mtime_ms, size FROM wiki_search_documents ORDER BY id").all();
+    const existing = new Map(existingRows.map((row) => [row.id, row]));
+    const present = new Set;
+    const changed = [];
+    for (const source of sources) {
+      const id = documentId(source);
+      present.add(id);
+      const stored = existing.get(id);
+      if (stored && stored.path === source.path && stored.mtime_ms === source.mtimeMs && stored.size === source.size) {
+        continue;
+      }
+      try {
+        const text = readFileSync(source.path, "utf-8");
+        changed.push({ source, document: prepare(source, text), added: !stored });
+      } catch {}
+    }
+    const removed = existingRows.filter((row) => !present.has(row.id));
+    const apply = this.#database.transaction(() => {
+      const deleteTerms = this.#database.query("DELETE FROM wiki_search_fts WHERE document_id = ?");
+      const deleteDocument = this.#database.query("DELETE FROM wiki_search_documents WHERE id = ?");
+      const insertDocument = this.#database.query(`
+        INSERT INTO wiki_search_documents
+          (id, kind, key, path, mtime_ms, size, title, text, date, family)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const insertTerms = this.#database.query(`
+        INSERT INTO wiki_search_fts(document_id, kind, tokens)
+        VALUES (?, ?, ?)
+      `);
+      for (const row of removed) {
+        deleteTerms.run(row.id);
+        deleteDocument.run(row.id);
+        result.removed += 1;
+      }
+      for (const { source, document, added } of changed) {
+        const id = documentId(source);
+        deleteTerms.run(id);
+        deleteDocument.run(id);
+        insertDocument.run(id, source.kind, source.key, source.path, source.mtimeMs, source.size, document.title, document.text, document.date ?? null, document.family ?? null);
+        insertTerms.run(id, source.kind, document.tokens.join(" "));
+        if (added)
+          result.added += 1;
+        else
+          result.updated += 1;
+      }
+    });
+    apply.immediate();
+    return result;
+  }
+  metadata(kinds) {
+    if (kinds.length === 0)
+      return [];
+    const placeholders = kinds.map(() => "?").join(", ");
+    const rows = this.#database.query(`SELECT id, kind, key, title, date
+         FROM wiki_search_documents
+         WHERE kind IN (${placeholders})`).all(...kinds);
+    return rows.map((row) => ({
+      id: row.id,
+      kind: row.kind,
+      key: row.key,
+      title: row.title,
+      ...row.date ? { date: row.date } : {}
+    }));
+  }
+  summaryMetadataByDate(query) {
+    const conditions = ["kind = 'summary'", "date IS NOT NULL"];
+    const parameters = [];
+    if (query.year && query.month) {
+      const month = Number(query.month);
+      const nextYear = month === 12 ? String(Number(query.year) + 1) : query.year;
+      const nextMonth = String(month === 12 ? 1 : month + 1).padStart(2, "0");
+      conditions.push("date >= ?", "date < ?");
+      parameters.push(`${query.year}-${query.month}-01`, `${nextYear}-${nextMonth}-01`);
+    } else if (query.year) {
+      conditions.push("date >= ?", "date < ?");
+      parameters.push(`${query.year}-01-01`, `${Number(query.year) + 1}-01-01`);
+    } else if (query.month) {
+      conditions.push("substr(date, 6, 2) = ?");
+      parameters.push(query.month);
+    }
+    parameters.push(query.limit);
+    const rows = this.#database.query(`SELECT id, kind, key, title, date
+         FROM wiki_search_documents
+         WHERE ${conditions.join(" AND ")}
+         ORDER BY date ${query.direction === "oldest" ? "ASC" : "DESC"}, key ASC
+         LIMIT ?`).all(...parameters);
+    return rows.map((row) => ({
+      id: row.id,
+      kind: row.kind,
+      key: row.key,
+      title: row.title,
+      ...row.date ? { date: row.date } : {}
+    }));
+  }
+  matchingDocumentIds(kinds, terms) {
+    if (kinds.length === 0 || terms.length === 0)
+      return new Set;
+    const kindPlaceholders = kinds.map(() => "?").join(", ");
+    const match = terms.map((term) => `"${term.replaceAll('"', '""')}"`).join(" OR ");
+    const rows = this.#database.query(`SELECT DISTINCT document_id
+         FROM wiki_search_fts
+         WHERE wiki_search_fts MATCH ? AND kind IN (${kindPlaceholders})`).all(match, ...kinds);
+    return new Set(rows.map((row) => row.document_id));
+  }
+  documents(ids) {
+    if (ids.size === 0)
+      return [];
+    const values = [...ids];
+    const rows = [];
+    for (let offset = 0;offset < values.length; offset += 500) {
+      const chunk = values.slice(offset, offset + 500);
+      const placeholders = chunk.map(() => "?").join(", ");
+      rows.push(...this.#database.query(`SELECT id, kind, key, path, title, text, date
+             FROM wiki_search_documents
+             WHERE id IN (${placeholders})`).all(...chunk));
+    }
+    return rows.map((row) => ({
+      id: row.id,
+      kind: row.kind,
+      key: row.key,
+      path: row.path,
+      title: row.title,
+      text: row.text,
+      tokens: [],
+      ...row.date ? { date: row.date } : {}
+    }));
+  }
+}
+function resetCorruptWikiSearchIndex(path) {
+  for (const candidate of [path, `${path}-journal`, `${path}-wal`, `${path}-shm`]) {
+    if (!existsSync(candidate))
+      continue;
+    unlinkSync(candidate);
+  }
+}
+
+// ../../packages/core/src/mcp/wiki-server.ts
+init_config();
+init_wiki_summary_names();
 var wikiRuntime = new AsyncLocalStorage;
 function runtime() {
   const current = wikiRuntime.getStore();
@@ -18241,15 +18508,15 @@ function acquireRecoveryGuard(lockPath) {
       } catch (error) {
         closeSync(fd);
         try {
-          unlinkSync(guardPath);
+          unlinkSync2(guardPath);
         } catch {}
         throw error;
       }
       return () => {
         closeSync(fd);
         try {
-          if (readFileSync2(guardPath, "utf-8") === ownerToken)
-            unlinkSync(guardPath);
+          if (readFileSync3(guardPath, "utf-8") === ownerToken)
+            unlinkSync2(guardPath);
         } catch {}
       };
     } catch (error) {
@@ -18274,7 +18541,7 @@ function acquireFileLock(path) {
       } catch (error) {
         closeSync(fd);
         try {
-          unlinkSync(lockPath);
+          unlinkSync2(lockPath);
         } catch {}
         throw error;
       }
@@ -18282,8 +18549,8 @@ function acquireFileLock(path) {
         closeSync(fd);
         const releaseGuard = acquireRecoveryGuard(lockPath);
         try {
-          if (readFileSync2(lockPath, "utf-8") === ownerToken)
-            unlinkSync(lockPath);
+          if (readFileSync3(lockPath, "utf-8") === ownerToken)
+            unlinkSync2(lockPath);
         } catch {} finally {
           releaseGuard();
         }
@@ -18294,9 +18561,9 @@ function acquireFileLock(path) {
       const releaseGuard = acquireRecoveryGuard(lockPath);
       try {
         try {
-          const staleToken = readFileSync2(lockPath, "utf-8");
-          if (Date.now() - statSync(lockPath).mtimeMs > FILE_LOCK_STALE_MS && readFileSync2(lockPath, "utf-8") === staleToken) {
-            unlinkSync(lockPath);
+          const staleToken = readFileSync3(lockPath, "utf-8");
+          if (Date.now() - statSync(lockPath).mtimeMs > FILE_LOCK_STALE_MS && readFileSync3(lockPath, "utf-8") === staleToken) {
+            unlinkSync2(lockPath);
             continue;
           }
         } catch {
@@ -18319,7 +18586,7 @@ function atomicWriteFile(path, content) {
     renameSync(temporaryPath, path);
   } catch (error) {
     try {
-      unlinkSync(temporaryPath);
+      unlinkSync2(temporaryPath);
     } catch {}
     throw error;
   }
@@ -18506,10 +18773,91 @@ function trigramSimilarity(left, right) {
       overlap += 1;
   return 2 * overlap / (a.size + b.size);
 }
+var WIKI_SEARCH_INDEX_FILENAME = ".wiki-search-index.sqlite";
+function openWikiSearchIndex() {
+  const path = resolve2(runtime().wikiDir, WIKI_SEARCH_INDEX_FILENAME);
+  try {
+    return new WikiSearchIndex(path);
+  } catch (error) {
+    if (!/malformed|not a database|schema/i.test(String(error)))
+      return;
+    try {
+      resetCorruptWikiSearchIndex(path);
+      return new WikiSearchIndex(path);
+    } catch {
+      return;
+    }
+  }
+}
+function prepareWikiSearchDocument(kind, key, text) {
+  const titleLine = text.split(`
+`).find((line) => /^#+\s*/.test(line)) ?? "";
+  const title = titleLine ? titleLine.replace(/^#+\s*/, "") : basename(key);
+  return {
+    title,
+    text,
+    tokens: canonicalSearchTokens(`${key} ${title} ${text}`),
+    ...kind === "summary" && /^\d{4}-\d{2}-\d{2}/.test(key) ? { date: key.slice(0, 10), family: summaryTopicIdentity(key) } : {}
+  };
+}
+function indexWikiSearchDocument(kind, key, text) {
+  const root = kind === "article" ? runtime().articlesDir : runtime().summariesDir;
+  const path = resolve2(root, `${key}.md`);
+  const index = openWikiSearchIndex();
+  if (!index)
+    return false;
+  try {
+    const stat = statSync(path);
+    index.upsert({ kind, key, path, mtimeMs: stat.mtimeMs, size: stat.size }, prepareWikiSearchDocument(kind, key, text));
+    return true;
+  } catch {
+    return false;
+  } finally {
+    index.close();
+  }
+}
+var WIKI_INDEX_FILENAMES = {
+  article: "article-index.md",
+  summary: "summary-index.md",
+  topic: "topic-index.md",
+  skill: "skill-index.md"
+};
+var WIKI_INDEX_NAMESPACES = {
+  article: "articles",
+  summary: "summaries",
+  topic: "topic",
+  skill: "skills"
+};
+function wikiIndexPath(kind) {
+  return resolve2(runtime().wikiDir, WIKI_INDEX_FILENAMES[kind]);
+}
+var MAX_INDEX_DESCRIPTION_LENGTH = 400;
+function normalizeIndexDescription(raw) {
+  const description = raw.replaceAll(/\s+/g, " ").trim();
+  if (!description)
+    return { error: "A non-empty one-line description is required." };
+  if (description.length > MAX_INDEX_DESCRIPTION_LENGTH) {
+    return {
+      error: `Description must be at most ${MAX_INDEX_DESCRIPTION_LENGTH} characters (got ${description.length}).`
+    };
+  }
+  return { description };
+}
+function normalizeWikiSlug(raw) {
+  const slug = raw.trim().replace(/\.md$/i, "").replace(/^\/+/, "");
+  if (!slug)
+    return { error: "A non-empty slug is required." };
+  if (/[[\]|\\]/.test(slug))
+    return { error: "Slug must not contain [ ] | or backslashes." };
+  if (slug.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) {
+    return { error: "Slug must not contain empty or relative path segments." };
+  }
+  return { slug };
+}
 function parseWikiIndex(path) {
   let text;
   try {
-    text = readFileSync2(path, "utf-8");
+    text = readFileSync3(path, "utf-8");
   } catch {
     return [];
   }
@@ -18663,7 +19011,7 @@ function wikiQuery(args) {
                   continue;
                 const fp = join2(sub, f.name);
                 try {
-                  const text = readFileSync2(fp, "utf-8");
+                  const text = readFileSync3(fp, "utf-8");
                   const key = `${entry.name}/${f.name.replace(/\.md$/i, "")}`;
                   scored.push({
                     kind: label === "articles" ? "article" : "skill",
@@ -18684,7 +19032,7 @@ function wikiQuery(args) {
           }
           const fp = join2(dir, entry.name);
           try {
-            const text = readFileSync2(fp, "utf-8");
+            const text = readFileSync3(fp, "utf-8");
             const key = entry.name.replace(/\.md$/i, "");
             const resultKind = label === "articles" ? "article" : label === "topic" ? "topic" : label === "summaries" ? "summary" : "skill";
             scored.push({
@@ -18798,14 +19146,45 @@ function wikiQuery(args) {
       return 0;
     return score;
   }
-  if (kind === "all" || kind === "article")
-    scan(runtime().articlesDir, "articles");
+  const bodyKinds = [
+    ...kind === "all" || kind === "article" ? ["article"] : [],
+    ...kind === "all" || kind === "summary" ? ["summary"] : []
+  ];
+  if (bodyKinds.length > 0) {
+    const searchIndex = openWikiSearchIndex();
+    if (searchIndex) {
+      try {
+        const terms = canonicalSearchTokens(normalizedQuery);
+        const ids = searchIndex.matchingDocumentIds(bodyKinds, terms);
+        if (temporalDirection && bodyKinds.includes("summary")) {
+          for (const item of searchIndex.summaryMetadataByDate({
+            direction: temporalDirection === "newest" ? "latest" : "oldest",
+            limit
+          })) {
+            ids.add(item.id);
+          }
+        }
+        for (const document of searchIndex.documents(ids)) {
+          scored.push({
+            kind: document.kind,
+            key: document.key,
+            keyScore: scoreIndexKey(question, document.key),
+            score: scoreMatch(document.text, document.key, document.kind),
+            path: `${document.kind === "article" ? "articles" : "summaries"}/${document.key}.md`,
+            text: document.text,
+            title: document.title,
+            ...document.date ? { date: document.date } : {}
+          });
+        }
+      } catch {} finally {
+        searchIndex.close();
+      }
+    }
+  }
   if (kind === "all" && runtime().surface === "all")
     scan(runtime().skillsDir, "skills");
   if (kind === "all" || kind === "topic")
     scan(runtime().topicsDir, "topic");
-  if (kind === "all" || kind === "summary")
-    scan(runtime().summariesDir, "summaries");
   const merged = new Map;
   for (const { candidate, keyScore, score } of indexCandidates) {
     merged.set(`${candidate.kind}:${candidate.key}`, {
@@ -18937,7 +19316,7 @@ function wikiTopicBrief(args) {
   const topicKey = wikiSummarySlug(rawTopic.replace(/^topic\//, "").replace(/\.md$/i, ""));
   const filePath = resolve2(runtime().topicsDir, `${topicKey}.md`);
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return {
       content: [{ type: "text", text: `# Topic Brief: ${topicKey}
 
@@ -18989,7 +19368,7 @@ Adopted topic memory: ${memoryKey}` }]
     return { content: [{ type: "text", text: "Invalid wiki document key." }], isError: true };
   }
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return {
       content: [{ type: "text", text: `# Wiki ${kind}: ${key}
 
@@ -19009,18 +19388,18 @@ function wikiLastConversation(args) {
   const name = slugify(topicNameFrom(rawTopic));
   const archiveDir = resolve2(runtime().archiveDir, name);
   try {
-    let files = existsSync2(archiveDir) ? readdirSync(archiveDir).filter((f) => f.endsWith(".jsonl")).sort().reverse() : [];
+    let files = existsSync3(archiveDir) ? readdirSync(archiveDir).filter((f) => f.endsWith(".jsonl")).sort().reverse() : [];
     if (files.length === 0) {
-      files = existsSync2(runtime().archiveDir) ? readdirSync(runtime().archiveDir).filter((f) => f.startsWith(name) && f.endsWith(".jsonl")).sort().reverse() : [];
+      files = existsSync3(runtime().archiveDir) ? readdirSync(runtime().archiveDir).filter((f) => f.startsWith(name) && f.endsWith(".jsonl")).sort().reverse() : [];
     }
     if (files.length === 0) {
       return {
         content: [{ type: "text", text: `No archive found for topic: ${rawTopic}` }]
       };
     }
-    const actualPath = files[0].includes("/") ? files[0] : resolve2(existsSync2(archiveDir) && readdirSync(archiveDir).includes(files[0]) ? archiveDir : runtime().archiveDir, files[0]);
+    const actualPath = files[0].includes("/") ? files[0] : resolve2(existsSync3(archiveDir) && readdirSync(archiveDir).includes(files[0]) ? archiveDir : runtime().archiveDir, files[0]);
     try {
-      const raw = readFileSync2(actualPath, "utf-8");
+      const raw = readFileSync3(actualPath, "utf-8");
       const lines = raw.trim().split(`
 `).filter(Boolean);
       const turns2 = [];
@@ -19093,7 +19472,7 @@ function skillQuery(args) {
         continue;
       const skillFile = resolve2(runtime().skillsDir, entry.name, "skill.md");
       try {
-        const text = readFileSync2(skillFile, "utf-8");
+        const text = readFileSync3(skillFile, "utf-8");
         const lower = text.toLowerCase();
         let score = 0;
         for (const w of query.split(/\s+/).filter(Boolean)) {
@@ -19164,7 +19543,7 @@ ${fresh.join(`
   const skillPath = resolve2(skillDir, "skill.md");
   let finalContent = content;
   try {
-    const existing = readFileSync2(skillPath, "utf-8");
+    const existing = readFileSync3(skillPath, "utf-8");
     finalContent = mergeGotchas(content, extractGotchas(existing));
   } catch {}
   writeFileSync2(skillPath, finalContent, "utf-8");
@@ -19177,15 +19556,7 @@ ${fresh.join(`
     ]
   };
 }
-function saveWikiEntry(args) {
-  const rawTopic = safeExt(args, ["topic", "topicName"], "");
-  const content = safeExt(args, ["content", "text", "body"], "");
-  if (!rawTopic)
-    return { content: [{ type: "text", text: "Missing topic." }] };
-  if (!content)
-    return { content: [{ type: "text", text: "Missing content." }] };
-  const now = new Date;
-  const dateStr = now.toISOString().slice(0, 10);
+function writeSummaryDocument(rawTopic, content, dateStr) {
   const topicId = runtime().topicId;
   const fileSlug = wikiBriefStorageKey(rawTopic, topicId);
   ensureDir(runtime().summariesDir);
@@ -19212,7 +19583,7 @@ function saveWikiEntry(args) {
   if (topicId && setTopicBrief) {
     try {
       const briefPath = resolve2(runtime().topicsDir, `${fileSlug}.md`);
-      let briefMd = existsSync2(briefPath) ? readFileSync2(briefPath, "utf-8") : undefined;
+      let briefMd = existsSync3(briefPath) ? readFileSync3(briefPath, "utf-8") : undefined;
       if (briefMd === undefined && getTopicBrief && !getTopicBrief(fileSlug)?.briefMd) {
         const legacy = getTopicBrief(topicId)?.briefMd;
         if (legacy)
@@ -19226,28 +19597,14 @@ function saveWikiEntry(args) {
       sqliteUpdated = true;
     } catch {}
   }
-  return {
-    content: [
-      {
-        type: "text",
-        text: `Saved summary: summaries/${summaryName}` + (sqliteUpdated ? `
-SQLite latest-summary also updated.` : "")
-      }
-    ]
-  };
+  return { slug: summaryName.replace(/\.md$/i, ""), sqliteUpdated };
 }
-function saveTopicBrief(args) {
-  const rawTopic = safeExt(args, ["topic", "topicName"], "");
-  const content = safeExt(args, ["content", "brief", "text", "body"], "");
-  if (!rawTopic)
-    return { content: [{ type: "text", text: "Missing topic." }] };
-  if (!content)
-    return { content: [{ type: "text", text: "Missing content." }] };
+function writeTopicDocument(rawTopic, content) {
   const topicId = runtime().topicId;
   const fileSlug = wikiBriefStorageKey(rawTopic, topicId);
   const briefPath = resolve2(runtime().topicsDir, `${fileSlug}.md`);
   ensureDir(dirname2(briefPath));
-  const existed = existsSync2(briefPath);
+  const existed = existsSync3(briefPath);
   writeFileSync2(briefPath, content, "utf-8");
   const setTopicBrief = runtime().host.setTopicBrief;
   let sqliteUpdated = false;
@@ -19257,68 +19614,228 @@ function saveTopicBrief(args) {
       sqliteUpdated = true;
     } catch {}
   }
+  return { slug: fileSlug, existed, sqliteUpdated };
+}
+function writeArticleDocument(slug, content) {
+  const articlePath = resolve2(runtime().articlesDir, `${slug}.md`);
+  ensureDir(dirname2(articlePath));
+  const existed = existsSync3(articlePath);
+  atomicWriteFile(articlePath, content);
+  return { existed };
+}
+function wikiWrite(args) {
+  const rawKind = safeExt(args, ["kind", "type"], "");
+  const content = safeExt(args, ["content", "text", "body", "brief"], "");
+  const rawDescription = safeExt(args, ["description", "desc"], "");
+  const rawTopic = safeExt(args, ["topic", "topicName"], "");
+  const rawSlug = safeExt(args, ["slug", "id"], "");
+  const section = safeExt(args, ["section", "category"], undefined);
+  const rawDate = safeExt(args, ["date", "created"], undefined);
+  if (rawKind !== "summary" && rawKind !== "article" && rawKind !== "topic") {
+    return {
+      content: [{ type: "text", text: 'kind must be one of "summary", "article", "topic".' }],
+      isError: true
+    };
+  }
+  if (!content.trim()) {
+    return { content: [{ type: "text", text: "Missing content." }], isError: true };
+  }
+  const descriptionResult = normalizeIndexDescription(rawDescription);
+  if ("error" in descriptionResult) {
+    return { content: [{ type: "text", text: descriptionResult.error }], isError: true };
+  }
+  const { description } = descriptionResult;
+  const today = new Date().toISOString().slice(0, 10);
+  if (rawKind === "article") {
+    const slugResult = normalizeWikiSlug(rawSlug);
+    if ("error" in slugResult) {
+      return { content: [{ type: "text", text: slugResult.error }], isError: true };
+    }
+    if (!section?.trim()) {
+      return {
+        content: [
+          { type: "text", text: "An article requires a section so the catalog stays navigable." }
+        ],
+        isError: true
+      };
+    }
+    const { existed } = writeArticleDocument(slugResult.slug, content);
+    const link2 = indexRowOrPartialWrite("article", {
+      kind: "article",
+      slug: slugResult.slug,
+      description,
+      date: rawDate ?? today,
+      section: section.trim()
+    });
+    if (typeof link2 !== "string")
+      return link2;
+    const searched = indexWikiSearchDocument("article", slugResult.slug, content);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Saved article: articles/${slugResult.slug}.md (${existed ? "updated" : "created"})
+Indexed: ${link2}` + (searched ? "" : `
+${SEARCH_CACHE_SKIPPED_NOTE}`)
+        }
+      ]
+    };
+  }
+  const topic = rawTopic.trim();
+  if (!topic) {
+    return { content: [{ type: "text", text: "Missing topic." }], isError: true };
+  }
+  if (rawKind === "summary") {
+    const dateStr = rawDate ?? today;
+    const written2 = writeSummaryDocument(topic, content, dateStr);
+    const link2 = indexRowOrPartialWrite("summary", {
+      kind: "summary",
+      slug: written2.slug,
+      description,
+      date: dateStr
+    });
+    if (typeof link2 !== "string")
+      return link2;
+    const searched = indexWikiSearchDocument("summary", written2.slug, content);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Saved summary: summaries/${written2.slug}.md
+Indexed: ${link2}` + (written2.sqliteUpdated ? `
+SQLite latest-summary also updated.` : "") + (searched ? "" : `
+${SEARCH_CACHE_SKIPPED_NOTE}`)
+        }
+      ]
+    };
+  }
+  const written = writeTopicDocument(topic, content);
+  const link = indexRowOrPartialWrite("topic", {
+    kind: "topic",
+    slug: written.slug,
+    description,
+    date: rawDate ?? today
+  });
+  if (typeof link !== "string")
+    return link;
   return {
     content: [
       {
         type: "text",
-        text: `Saved brief: topic/${fileSlug}.md (${existed ? "updated" : "created"})` + (sqliteUpdated ? `
+        text: `Saved brief: topic/${written.slug}.md (${written.existed ? "updated" : "created"})
+Indexed: ${link}` + (written.sqliteUpdated ? `
 SQLite brief also updated.` : "")
       }
     ]
   };
 }
-function indexUpsert(args) {
-  const slug = safeExt(args, ["slug", "id"], "");
-  const desc = safeExt(args, ["description", "desc", "text"], "");
-  const kind = safeExt(args, ["kind", "type"], "article");
-  const section = safeExt(args, ["section", "category"], undefined);
-  const date = safeExt(args, ["date", "created"], undefined);
-  if (!slug)
-    return { content: [{ type: "text", text: "Missing slug." }] };
-  const today = new Date().toISOString().slice(0, 10);
-  const dateStr = date ?? today;
-  const indexPath = (() => {
-    if (kind === "topic")
-      return resolve2(runtime().wikiDir, "topic-index.md");
-    if (kind === "skill")
-      return resolve2(runtime().wikiDir, "skill-index.md");
-    return resolve2(runtime().wikiDir, "article-index.md");
-  })();
+function collectIndexableDocuments() {
+  const sources = [];
+  function add(kind, key, path) {
+    try {
+      const stat = statSync(path);
+      if (!stat.isFile())
+        return;
+      sources.push({ kind, key, path, mtimeMs: stat.mtimeMs, size: stat.size });
+    } catch {}
+  }
+  for (const [root, kind, allowSubdirectories] of [
+    [runtime().articlesDir, "article", true],
+    [runtime().summariesDir, "summary", false]
+  ]) {
+    let entries;
+    try {
+      entries = readdirSync(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        add(kind, entry.name.replace(/\.md$/i, ""), join2(root, entry.name));
+        continue;
+      }
+      if (!entry.isDirectory() || !allowSubdirectories)
+        continue;
+      let nested;
+      try {
+        nested = readdirSync(join2(root, entry.name), { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const file of nested) {
+        if (!file.isFile() || !file.name.endsWith(".md"))
+          continue;
+        add(kind, `${entry.name}/${file.name.replace(/\.md$/i, "")}`, join2(root, entry.name, file.name));
+      }
+    }
+  }
+  return sources;
+}
+function wikiReindex() {
+  const documents = collectIndexableDocuments();
+  const index = openWikiSearchIndex();
+  if (!index) {
+    return {
+      content: [{ type: "text", text: "Could not open the wiki search index." }],
+      isError: true
+    };
+  }
+  let synced;
+  try {
+    synced = index.sync(documents, (source, text) => prepareWikiSearchDocument(source.kind, source.key, text));
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Failed to rebuild the search index: ${String(error)}` }],
+      isError: true
+    };
+  } finally {
+    index.close();
+  }
+  const lines = [
+    `Search index: ${synced.added} added, ${synced.updated} updated, ${synced.removed} removed (${documents.length} documents).`
+  ];
+  for (const kind of ["article", "summary"]) {
+    const rows = new Set(parseWikiIndex(wikiIndexPath(kind)).filter((candidate) => candidate.kind === kind).map((candidate) => candidate.key));
+    const keys = documents.filter((source) => source.kind === kind).map((source) => source.key);
+    const unindexed = keys.filter((key) => !rows.has(key));
+    const tombstones = [...rows].filter((key) => !keys.includes(key));
+    lines.push(`${WIKI_INDEX_FILENAMES[kind]}: ${rows.size} rows for ${keys.length} documents` + (unindexed.length > 0 ? `; missing rows: ${unindexed.join(", ")}` : "") + (tombstones.length > 0 ? `; tombstones: ${tombstones.join(", ")}` : ""));
+  }
+  return { content: [{ type: "text", text: lines.join(`
+`) }] };
+}
+var SEARCH_CACHE_SKIPPED_NOTE = "Body-search cache was not updated; catalog retrieval still works. Run wiki_reindex to refill it.";
+function indexRowOrPartialWrite(label, options) {
+  try {
+    return upsertIndexRow(options);
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Wrote the ${label} document but failed to index it (${String(error)}). Retry the same wiki_write call: both writes are idempotent.`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+function upsertIndexRow(options) {
+  const { kind, slug, description, date, section } = options;
+  const indexPath = wikiIndexPath(kind);
   ensureDir(dirname2(indexPath));
   const releaseLock = acquireFileLock(indexPath);
   try {
     let index;
     try {
-      index = readFileSync2(indexPath, "utf-8");
+      index = readFileSync3(indexPath, "utf-8");
     } catch {
       index = "";
     }
     const lines = index.split(`
 `);
-    const link = (() => {
-      switch (kind) {
-        case "summary":
-          return `- [[summaries/${slug}]] ${desc} (${dateStr})`;
-        case "topic":
-          return `- [[topic/${slug}]] ${desc} (${dateStr})`;
-        case "skill":
-          return `- [[skills/${slug}]] ${desc} (${dateStr})`;
-        default:
-          return `- [[articles/${slug}]] ${desc} (${dateStr})`;
-      }
-    })();
-    const target = (() => {
-      switch (kind) {
-        case "summary":
-          return `summaries/${slug}`;
-        case "topic":
-          return `topic/${slug}`;
-        case "skill":
-          return `skills/${slug}`;
-        default:
-          return `articles/${slug}`;
-      }
-    })();
+    const target = `${WIKI_INDEX_NAMESPACES[kind]}/${slug}`;
+    const link = `- [[${target}]] ${description} (${date})`;
     const slugPattern = `[[${target}]]`;
     let replaced = false;
     for (let i = lines.length - 1;i >= 0; i--) {
@@ -19356,11 +19873,63 @@ function indexUpsert(args) {
     }
     atomicWriteFile(indexPath, lines.join(`
 `));
-    return { content: [{ type: "text", text: `Index updated: ${link}` }] };
+    return link;
   } finally {
     releaseLock();
   }
 }
+function wikiDocumentExists(kind, slug) {
+  const root = kind === "article" ? runtime().articlesDir : kind === "summary" ? runtime().summariesDir : kind === "topic" ? runtime().topicsDir : runtime().skillsDir;
+  const filePath = resolve2(root, `${slug}.md`);
+  if (relative(root, filePath).startsWith(".."))
+    return false;
+  try {
+    return statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function indexUpsert(args) {
+  const rawSlug = safeExt(args, ["slug", "id"], "");
+  const rawDescription = safeExt(args, ["description", "desc", "text"], "");
+  const rawKind = safeExt(args, ["kind", "type"], "article");
+  const section = safeExt(args, ["section", "category"], undefined);
+  const date = safeExt(args, ["date", "created"], undefined);
+  if (!(rawKind in WIKI_INDEX_FILENAMES)) {
+    return {
+      content: [{ type: "text", text: `Unsupported kind: ${rawKind}` }],
+      isError: true
+    };
+  }
+  const kind = rawKind;
+  const slugResult = normalizeWikiSlug(rawSlug);
+  if ("error" in slugResult) {
+    return { content: [{ type: "text", text: slugResult.error }], isError: true };
+  }
+  const descriptionResult = normalizeIndexDescription(rawDescription);
+  if ("error" in descriptionResult) {
+    return { content: [{ type: "text", text: descriptionResult.error }], isError: true };
+  }
+  if (kind !== "topic" && !wikiDocumentExists(kind, slugResult.slug)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No ${kind} document named ${slugResult.slug}. Use wiki_write to create the document and its catalog row together.`
+        }
+      ],
+      isError: true
+    };
+  }
+  const link = upsertIndexRow({
+    kind,
+    slug: slugResult.slug,
+    description: descriptionResult.description,
+    date: date ?? new Date().toISOString().slice(0, 10),
+    section
+  });
+  return { content: [{ type: "text", text: `Index updated: ${link}` }] };
+}
 var WIKI_TOOLS = [
   {
     name: "wiki_query",
@@ -19442,35 +20011,46 @@ var WIKI_TOOLS = [
     }
   },
   {
-    name: "save_wiki_entry",
-    description: "Save a session summary directly to wiki/summaries/.",
+    name: "wiki_write",
+    description: "Write a wiki document and its catalog row together. The only way to create a summary, article, or topic brief: summaries go to wiki/summaries/ + summary-index.md, articles to wiki/articles/ + article-index.md, briefs to wiki/topic/ + topic-index.md (also mirrored into SQLite for next-session injection). Never write wiki files by any other means.",
     inputSchema: {
       type: "object",
       properties: {
-        topic: { type: "string", description: "Topic name of the session" },
-        content: { type: "string", description: "Session summary in markdown" }
+        kind: {
+          type: "string",
+          enum: ["summary", "article", "topic"],
+          description: "Which document to write"
+        },
+        content: { type: "string", description: "Document body in markdown" },
+        description: {
+          type: "string",
+          description: "Single-line catalog description; required so the index stays useful"
+        },
+        topic: {
+          type: "string",
+          description: "Topic name; required for kind=summary and kind=topic"
+        },
+        slug: {
+          type: "string",
+          description: "Article slug in kebab-case; required for kind=article"
+        },
+        section: {
+          type: "string",
+          description: "H2 catalog section; required for kind=article"
+        },
+        date: { type: "string", description: "Override entry date YYYY-MM-DD (default: today)" }
       },
-      required: ["topic", "content"]
+      required: ["kind", "content", "description"]
     }
   },
   {
-    name: "save_topic_brief",
-    description: "Write the accumulated persona/topic brief to wiki/topic/<topic>.md and mirror it into SQLite for next-session injection. Call this AFTER save_wiki_entry (archive \u2192 summary \u2192 brief order).",
-    inputSchema: {
-      type: "object",
-      properties: {
-        topic: { type: "string", description: "Topic name of the session" },
-        content: {
-          type: "string",
-          description: "Full accumulated topic brief in markdown (persona layer + recent work)"
-        }
-      },
-      required: ["topic", "content"]
-    }
+    name: "wiki_reindex",
+    description: "Rebuild the derived body-search cache from the documents on disk and report catalog gaps. Run this once after adding documents outside wiki_write; retrieval itself never scans the wiki.",
+    inputSchema: { type: "object", properties: {} }
   },
   {
     name: "index_upsert",
-    description: "Upsert an entry in wiki/article-index.md, topic-index.md, or skill-index.md.",
+    description: "Correct the description or section of an entry that already exists. Cannot create an entry \u2014 use wiki_write for that.",
     inputSchema: {
       type: "object",
       properties: {
@@ -19574,8 +20154,8 @@ function createWikiMcpServer(context, host) {
         wiki_last_conversation: wikiLastConversation,
         skill_query: skillQuery,
         skill_save: skillSave,
-        save_wiki_entry: saveWikiEntry,
-        save_topic_brief: saveTopicBrief,
+        wiki_write: wikiWrite,
+        wiki_reindex: wikiReindex,
         index_upsert: indexUpsert
       };
       const handler = tools.some((tool) => tool.name === name) ? handlers[name] : undefined;
@@ -19593,8 +20173,8 @@ init_jsonl();
 init_mcp_helpers();
 await init_codex_registry();
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync3 } from "fs";
+import { join as join11 } from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 function signalProcessTree(child, signal) {
@@ -19610,7 +20190,7 @@ function signalProcessTree(child, signal) {
   }
 }
 function spawnCapture(cmd, args, timeoutMs, signal, env) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve8, reject) => {
     const child = spawn5(cmd, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -19668,7 +20248,7 @@ function spawnCapture(cmd, args, timeoutMs, signal, env) {
       if (killTimer)
         clearTimeout(killTimer);
       if (code === 0)
-        resolve7({ stdout, stderr });
+        resolve8({ stdout, stderr });
       else
         reject(new Error(stderr.trim() || `${cmd} exited with ${code ?? exitSignal}`));
     });
@@ -19746,11 +20326,11 @@ async function checkMaestro(model, timeoutMs, signal) {
       const remaining = deadline - Date.now();
       if (remaining <= 0)
         throw new Error("timeout");
-      const eventResult = await new Promise((resolve7, reject) => {
+      const eventResult = await new Promise((resolve8, reject) => {
         const timeout = setTimeout(() => reject(new Error("timeout")), remaining);
         const onAbort = () => reject(new Error("aborted"));
         signal.addEventListener("abort", onAbort, { once: true });
-        activeIterator.next().then(resolve7, reject).finally(() => {
+        activeIterator.next().then(resolve8, reject).finally(() => {
           clearTimeout(timeout);
           signal.removeEventListener("abort", onAbort);
         });
@@ -19789,7 +20369,7 @@ var checkWaiters = [];
 var activeCheckAllUsers = new Set;
 async function withCheckSlot(operation) {
   if (activeChecks >= MAX_CONCURRENT_CHECKS) {
-    await new Promise((resolve7) => checkWaiters.push(resolve7));
+    await new Promise((resolve8) => checkWaiters.push(resolve8));
   }
   activeChecks += 1;
   try {
@@ -19847,8 +20427,8 @@ ${results.every((result) => result.ok) ? "All agents healthy" : "Some agents fai
   server.tool("list_active_queries", "\uD604\uC7AC \uC0AC\uC6A9\uC790 \uBC94\uC704\uC5D0\uC11C \uC2E4\uD589 \uC911\uC778 \uD1A0\uD53D \uCFFC\uB9AC \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4.", {}, async () => {
     if (!context.userId)
       return mcpOk("\uC2E4\uD589 \uC911\uC778 \uCFFC\uB9AC \uC870\uD68C \uBD88\uAC00 (user context \uC5C6\uC74C)");
-    const stateDir = join10(USERS_LOG_DIR, context.userId, "active-queries");
-    if (!existsSync9(stateDir))
+    const stateDir = join11(USERS_LOG_DIR, context.userId, "active-queries");
+    if (!existsSync10(stateDir))
       return mcpOk("\uC2E4\uD589 \uC911\uC778 \uCFFC\uB9AC \uC5C6\uC74C");
     let files;
     try {
@@ -19860,7 +20440,7 @@ ${results.every((result) => result.ok) ? "All agents healthy" : "Some agents fai
     const entries = files.flatMap((file) => {
       if (!file.endsWith(".json"))
         return [];
-      const state = readJsonFile(join10(stateDir, file));
+      const state = readJsonFile(join11(stateDir, file));
       if (!state)
         return [];
       const sinceMs = new Date(state.since).getTime();
@@ -19885,7 +20465,7 @@ ${lines.join(`
 }
 // ../../packages/core/src/mcp/factories/compaction-log.ts
 init_mcp_helpers();
-import { readFileSync as readFileSync8, realpathSync as realpathSync3 } from "fs";
+import { readFileSync as readFileSync9, realpathSync as realpathSync3 } from "fs";
 import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z2 } from "zod";
 var DEFAULT_MAX_CALLS = 12;
@@ -19918,7 +20498,7 @@ function createCompactionLogMcpServer(context) {
   if (!context.filePath)
     throw new Error("compaction-log MCP requires filePath");
   const filePath = realpathSync3(context.filePath);
-  const lines = readFileSync8(filePath, "utf8").split(`
+  const lines = readFileSync9(filePath, "utf8").split(`
 `);
   const maxCalls = positiveInt(context.maxCalls, DEFAULT_MAX_CALLS);
   const maxTotalBytes = positiveInt(context.maxTotalBytes, DEFAULT_MAX_TOTAL_BYTES);
@@ -20511,4 +21091,4 @@ export {
   createAgentHealthMcpServer
 };
 
-//# debugId=AE60D4AF576C043E64756E2164756E21
+//# debugId=B2D00F1A1BBBDD6C64756E2164756E21