negotium 0.3.13 → 0.4.0

package/dist/main.js

@@ -1869,7 +1869,7 @@ var exports_version = {};
 __export(exports_version, {
   NEGOTIUM_VERSION: () => NEGOTIUM_VERSION
 });
-var NEGOTIUM_VERSION = "0.3.13";
+var NEGOTIUM_VERSION = "0.4.0";
 
 // ../../packages/core/src/agents/codex-native-multi-agent.ts
 import { spawn } from "child_process";
@@ -2139,30 +2139,21 @@ function shouldSubstituteVaultToolInput(toolName) {
   const leaf = leafToolName(toolName);
   return leaf.startsWith("browser_") || DIRECT_VAULT_EXECUTION_TOOLS.has(leaf);
 }
-function createVaultToolPolicy(host) {
-  function isVaultBrokerTool(toolName) {
-    return toolName.includes("vault_run") || toolName.includes("vault_http_request");
-  }
-  function referencesRuntimeSecretStorage(value) {
-    if (typeof value === "string") {
-      const lower = value.toLowerCase();
-      if (SENSITIVE_RUNTIME_NAMES.some((name) => lower.includes(name)))
-        return true;
-      return value.startsWith("/") && host.isSensitivePath(value);
-    }
-    if (Array.isArray(value))
-      return value.some(referencesRuntimeSecretStorage);
-    if (value && typeof value === "object") {
-      return Object.values(value).some(referencesRuntimeSecretStorage);
-    }
-    return false;
+function referencesRuntimeSecretStorage(value) {
+  if (typeof value === "string") {
+    const lower = value.toLowerCase();
+    if (SENSITIVE_RUNTIME_NAMES.some((name) => lower.includes(name)))
+      return true;
+    return value.startsWith("/") && isSensitivePath(value);
   }
-  function shouldRedirectVaultTool(userId, toolName, input) {
-    return false;
+  if (Array.isArray(value))
+    return value.some(referencesRuntimeSecretStorage);
+  if (value && typeof value === "object") {
+    return Object.values(value).some(referencesRuntimeSecretStorage);
   }
-  return { isVaultBrokerTool, referencesRuntimeSecretStorage, shouldRedirectVaultTool };
+  return false;
 }
-var SENSITIVE_RUNTIME_NAMES, DIRECT_VAULT_EXECUTION_TOOLS, defaultVaultToolPolicy, isVaultBrokerTool, referencesRuntimeSecretStorage, shouldRedirectVaultTool;
+var SENSITIVE_RUNTIME_NAMES, DIRECT_VAULT_EXECUTION_TOOLS;
 var init_vault_tool_policy = __esm(() => {
   init_sensitive_path();
   SENSITIVE_RUNTIME_NAMES = [
@@ -2172,13 +2163,6 @@ var init_vault_tool_policy = __esm(() => {
     "sessions.db"
   ];
   DIRECT_VAULT_EXECUTION_TOOLS = new Set(["Bash", "WebFetch"]);
-  defaultVaultToolPolicy = createVaultToolPolicy({
-    isSensitivePath,
-    valueReferencesVaultKey: () => false
-  });
-  isVaultBrokerTool = defaultVaultToolPolicy.isVaultBrokerTool;
-  referencesRuntimeSecretStorage = defaultVaultToolPolicy.referencesRuntimeSecretStorage;
-  shouldRedirectVaultTool = defaultVaultToolPolicy.shouldRedirectVaultTool;
 });
 
 // ../../packages/core/src/mcp/canonical-bridge-config.ts
@@ -3317,7 +3301,6 @@ var init_execution_host = __esm(async () => {
     redactVaultSecrets,
     substituteVaultSecrets: (userId, value) => vaultSubstituteDetailed(userId, value).text,
     referencesRuntimeSecretStorage,
-    shouldRedirectVaultTool,
     claudeCodeExecutablePath: () => CLAUDE_EXECUTABLE,
     codexAuthFilePath
   };
@@ -5256,9 +5239,163 @@ var init_claude_provider = __esm(async () => {
   ]);
 });
 
+// ../../packages/core/src/agents/codex-vault-hook-bridge.ts
+import { randomBytes as randomBytes5 } from "crypto";
+import { existsSync as existsSync13 } from "fs";
+import { chmod, mkdtemp, rm, writeFile } from "fs/promises";
+import { createServer } from "net";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname9, join as join13, resolve as resolve7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function evaluateCodexVaultPreToolUse(input, userId, operations) {
+  if (operations.referencesSensitiveStorage(input.tool_input)) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: SENSITIVE_STORAGE_DENIAL
+      }
+    };
+  }
+  if (!shouldSubstituteVaultToolInput(input.tool_name))
+    return {};
+  const updatedInput = deepMapStrings(input.tool_input, (value) => operations.substitute(userId, value));
+  if (JSON.stringify(updatedInput) === JSON.stringify(input.tool_input))
+    return {};
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      updatedInput
+    }
+  };
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function hookClientPath() {
+  const moduleDir = dirname9(fileURLToPath2(import.meta.url));
+  const adjacent = resolve7(moduleDir, "codex-vault-hook.mjs");
+  if (existsSync13(adjacent))
+    return adjacent;
+  const packaged = resolve7(moduleDir, "runtime/src/agents/codex-vault-hook.mjs");
+  if (existsSync13(packaged))
+    return packaged;
+  throw new Error("Codex Vault hook client is missing from this installation");
+}
+function privateCodexWrapper(codexScript) {
+  return [
+    "#!/bin/sh",
+    'if [ "$1" = "exec" ]; then',
+    "  shift",
+    `  exec ${shellQuote(process.execPath)} ${shellQuote(codexScript)} exec --dangerously-bypass-hook-trust "$@"`,
+    "fi",
+    `exec ${shellQuote(process.execPath)} ${shellQuote(codexScript)} "$@"`,
+    ""
+  ].join(`
+`);
+}
+async function createCodexVaultHookBridge(userId) {
+  const root = await mkdtemp(join13(tmpdir2(), "negotium-codex-vault-"));
+  await chmod(root, 448);
+  const socketPath = join13(root, "hook.sock");
+  const wrapperPath = join13(root, "codex-with-hooks");
+  const token = randomBytes5(32).toString("hex");
+  const connections = new Set;
+  const server = createServer((socket) => {
+    connections.add(socket);
+    socket.once("close", () => connections.delete(socket));
+    socket.setEncoding("utf8");
+    let request = "";
+    let handled = false;
+    const handleRequest = () => {
+      if (handled)
+        return;
+      handled = true;
+      try {
+        const parsed = JSON.parse(request.trimEnd());
+        if (parsed.token !== token)
+          throw new Error("invalid hook capability");
+        if (!parsed.input || typeof parsed.input !== "object" || typeof parsed.input.tool_name !== "string") {
+          throw new Error("invalid PreToolUse payload");
+        }
+        const output = evaluateCodexVaultPreToolUse(parsed.input, userId, {
+          referencesSensitiveStorage: referencesHostedSecretStorage,
+          substitute: substituteHostedSecrets
+        });
+        socket.end(JSON.stringify({ ok: true, output }));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        socket.end(JSON.stringify({ ok: false, error: message }));
+      }
+    };
+    socket.on("data", (chunk) => {
+      request += chunk;
+      if (Buffer.byteLength(request) > MAX_HOOK_REQUEST_BYTES)
+        socket.destroy();
+      else if (request.endsWith(`
+`))
+        handleRequest();
+    });
+    socket.on("end", handleRequest);
+  });
+  try {
+    await new Promise((resolveListen, reject) => {
+      server.once("error", reject);
+      server.listen(socketPath, () => {
+        server.off("error", reject);
+        resolveListen();
+      });
+    });
+    await chmod(socketPath, 384);
+    await writeFile(wrapperPath, privateCodexWrapper(codexCliScriptPath()), { mode: 448 });
+    const command = [
+      shellQuote(process.execPath),
+      shellQuote(hookClientPath()),
+      shellQuote(socketPath),
+      shellQuote(token)
+    ].join(" ");
+    return {
+      codexPathOverride: wrapperPath,
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: "*",
+            hooks: [
+              {
+                type: "command",
+                command,
+                timeout: 30,
+                statusMessage: "Resolving Vault placeholders"
+              }
+            ]
+          }
+        ]
+      },
+      async close() {
+        for (const socket of connections)
+          socket.destroy();
+        await new Promise((resolveClose) => server.close(() => resolveClose()));
+        await rm(root, { recursive: true, force: true });
+      }
+    };
+  } catch (error) {
+    server.close();
+    await rm(root, { recursive: true, force: true });
+    throw error;
+  }
+}
+var MAX_HOOK_REQUEST_BYTES, SENSITIVE_STORAGE_DENIAL = "Runtime secret storage access is not permitted";
+var init_codex_vault_hook_bridge = __esm(async () => {
+  init_codex_native_multi_agent();
+  await init_execution_host();
+  init_vault_tool_policy();
+  MAX_HOOK_REQUEST_BYTES = 1024 * 1024;
+});
+
 // ../../packages/core/src/agents/tool-format.ts
 import { readFileSync as readFileSync10, statSync as statSync4 } from "fs";
-import { isAbsolute, resolve as resolve7 } from "path";
+import { isAbsolute, resolve as resolve8 } from "path";
 import { diffLines as computeLineDiff } from "diff";
 function summarizeDisplayText(value) {
   const normalized = value.replace(/\s+/g, " ").trim();
@@ -5582,7 +5719,7 @@ function sourceStartLine(input, before, after, cwd) {
   const rawPath = input.file_path ?? input.path;
   if (typeof rawPath !== "string" || !rawPath.trim())
     return 1;
-  const path = isAbsolute(rawPath) ? rawPath : resolve7(cwd ?? process.cwd(), rawPath);
+  const path = isAbsolute(rawPath) ? rawPath : resolve8(cwd ?? process.cwd(), rawPath);
   try {
     if (statSync4(path).size > TOOL_DIFF_SOURCE_MAX_BYTES)
       return 1;
@@ -5780,9 +5917,9 @@ __export(exports_codex_provider, {
   codexProvider: () => codexProvider
 });
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync11, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11, realpathSync as realpathSync3, statSync as statSync5 } from "fs";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname9, isAbsolute as isAbsolute2, join as join13, relative, resolve as resolve8 } from "path";
+import { dirname as dirname10, isAbsolute as isAbsolute2, join as join14, relative, resolve as resolve9 } from "path";
 import { Codex } from "@openai/codex-sdk";
 function sameCodexUsage(usage, total) {
   return usage.input_tokens === total.inputTokens && usage.output_tokens === total.outputTokens && (usage.cached_input_tokens ?? 0) === total.cachedInputTokens && (usage.cache_write_input_tokens ?? 0) === total.cacheWriteInputTokens;
@@ -5810,8 +5947,8 @@ function codexMcpServerName(name) {
   return CODEX_MCP_SERVER_NAME_OVERRIDES[name] ?? name;
 }
 function globalCodexMcpServerNames(authFilePath) {
-  const configPath = join13(dirname9(authFilePath), "config.toml");
-  if (!existsSync13(configPath))
+  const configPath = join14(dirname10(authFilePath), "config.toml");
+  if (!existsSync14(configPath))
     return [];
   try {
     const names = new Set;
@@ -5906,13 +6043,13 @@ function summarizeMcpToolCallResult(item) {
 }
 function canonicalPath(path) {
   try {
-    return realpathSync3(resolve8(path));
+    return realpathSync3(resolve9(path));
   } catch {
-    return resolve8(path);
+    return resolve9(path);
   }
 }
 function textFile(path, maxBytes = CODEX_DIFF_FILE_LIMIT) {
-  if (!existsSync13(path))
+  if (!existsSync14(path))
     return null;
   try {
     const byteLimit = Math.min(CODEX_DIFF_FILE_LIMIT, Math.max(0, maxBytes));
@@ -5952,7 +6089,7 @@ class CodexFilePreviewTracker {
       const code = record.slice(0, 2);
       const path = record.slice(3);
       const remainingBytes = CODEX_DIFF_BASELINE_BYTE_LIMIT - loadedBytes;
-      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve8(this.#root, path), remainingBytes) : undefined;
+      const content = loadedFiles < CODEX_DIFF_BASELINE_FILE_LIMIT && remainingBytes > 0 ? textFile(resolve9(this.#root, path), remainingBytes) : undefined;
       this.#baseline.set(path, content);
       if (typeof content === "string") {
         loadedFiles += 1;
@@ -5965,7 +6102,7 @@ class CodexFilePreviewTracker {
   preview(path, succeeded) {
     if (!this.#root || !this.#baselineAvailable || !succeeded)
       return {};
-    const absolute = canonicalPath(isAbsolute2(path) ? path : resolve8(this.#cwd, path));
+    const absolute = canonicalPath(isAbsolute2(path) ? path : resolve9(this.#cwd, path));
     const relativePath = relative(this.#root, absolute);
     if (!relativePath || relativePath.startsWith("..") || isAbsolute2(relativePath))
       return {};
@@ -6000,7 +6137,7 @@ class CodexFilePreviewTracker {
   }
 }
 async function fileChangeEvents(item, previews, cwd, threadId, consumedPatchCallIds) {
-  const expectedPaths = item.changes.map((change) => isAbsolute2(change.path) ? change.path : resolve8(cwd, change.path));
+  const expectedPaths = item.changes.map((change) => isAbsolute2(change.path) ? change.path : resolve9(cwd, change.path));
   let nativePreview;
   if (threadId && item.status === "completed") {
     await new Promise((resolveDelay) => setTimeout(resolveDelay, 20));
@@ -6124,7 +6261,7 @@ async function* codexProvider(opts) {
   const filePreviews = new CodexFilePreviewTracker(opts.cwd);
   const consumedPatchCallIds = new Set(opts.sessionId ? readCodexPatchCallIds(opts.sessionId) : []);
   const codexAuthPath = hostedCodexAuthFilePath();
-  if (!existsSync13(codexAuthPath)) {
+  if (!existsSync14(codexAuthPath)) {
     yield {
       type: "error",
       content: `Codex auth file not found at ${codexAuthPath}. Run \`codex login\` to authenticate.`
@@ -6163,21 +6300,30 @@ async function* codexProvider(opts) {
     model: opts.model ?? "(sdk default)",
     effort: opts.effort ?? "(off)",
     cwd: opts.cwd,
-    cwdExists: existsSync13(opts.cwd),
+    cwdExists: existsSync14(opts.cwd),
     resume: Boolean(opts.sessionId),
     mcpServerCount: Object.keys(codexMcpServers).length
   }, "codexProvider: starting turn");
   const hostedCodexHome = hostedCodexHomePath();
-  const inheritedCodexHome = process.env.CODEX_HOME || join13(homedir7(), ".codex");
-  const codexEnvironment = scopedBrowserCapability || resolve8(hostedCodexHome) !== resolve8(inheritedCodexHome) ? {
+  const inheritedCodexHome = process.env.CODEX_HOME || join14(homedir7(), ".codex");
+  const codexEnvironment = scopedBrowserCapability || resolve9(hostedCodexHome) !== resolve9(inheritedCodexHome) ? {
     ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
     CODEX_HOME: hostedCodexHome,
     ...scopedBrowserCapability ? { [CODEX_BROWSER_CAPABILITY_ENV]: scopedBrowserCapability } : {}
   } : undefined;
+  let vaultHook;
+  try {
+    vaultHook = await createCodexVaultHookBridge(opts.vaultUserId ?? opts.userId ?? "");
+  } catch (err) {
+    yield { type: "error", content: `Failed to initialize Codex Vault hooks: ${errMsg(err)}` };
+    return;
+  }
   const codex = new Codex({
+    codexPathOverride: vaultHook.codexPathOverride,
     ...codexEnvironment ? { env: codexEnvironment } : {},
     config: {
-      features: { multi_agent: false, multi_agent_v2: false, enable_fanout: false },
+      features: { hooks: true, multi_agent: false, multi_agent_v2: false, enable_fanout: false },
+      hooks: vaultHook.hooks,
       model_catalog_json: codexModelCatalogPath,
       mcp_servers: codexMcpServers,
       ...opts.toolPolicy ? { sandbox_permissions: [] } : {}
@@ -6281,7 +6427,7 @@ async function* codexProvider(opts) {
               if (!item)
                 break;
               if (item.type === "command_execution") {
-                const command = String(item.command ?? "");
+                const command = redactHostedSecrets(opts.vaultUserId ?? opts.userId ?? "", String(item.command ?? ""));
                 yield {
                   type: "tool_use",
                   name: "Bash",
@@ -6289,10 +6435,11 @@ async function* codexProvider(opts) {
                   toolUseId: String(item.id ?? "")
                 };
               } else if (item.type === "mcp_tool_call") {
+                const input = item.arguments && typeof item.arguments === "object" ? item.arguments : {};
                 yield {
                   type: "tool_use",
                   name: String(item.tool ?? "unknown"),
-                  input: item.arguments && typeof item.arguments === "object" ? item.arguments : {},
+                  input: deepMapStrings(input, (value) => redactHostedSecrets(opts.vaultUserId ?? opts.userId ?? "", value)),
                   toolUseId: String(item.id ?? "")
                 };
               }
@@ -6335,7 +6482,7 @@ async function* codexProvider(opts) {
                 yield {
                   type: "tool_result",
                   toolUseId: String(item.id ?? ""),
-                  content: summarizeMcpToolCallResult(item),
+                  content: redactHostedSecrets(opts.vaultUserId ?? opts.userId ?? "", summarizeMcpToolCallResult(item)),
                   ...isError ? { isError: true } : {}
                 };
               } else if (item.type === "command_execution") {
@@ -6343,7 +6490,7 @@ async function* codexProvider(opts) {
                 yield {
                   type: "tool_result",
                   toolUseId: String(item.id ?? ""),
-                  content: String(item.aggregated_output ?? "").slice(0, 200),
+                  content: redactHostedSecrets(opts.vaultUserId ?? opts.userId ?? "", String(item.aggregated_output ?? "").slice(0, 200)),
                   ...isError ? { isError: true } : {}
                 };
               } else if (item.type === "file_change") {
@@ -6440,12 +6587,14 @@ async function* codexProvider(opts) {
     abortSignal?.removeEventListener("abort", onAbortKill);
     if (trackedPids.pids.length > 0)
       unregisterOwnedCodexPids(trackedPids.pids);
+    await vaultHook.close();
   }
 }
 var CODEX_MCP_SERVER_NAME_OVERRIDES, CODEX_DIFF_FILE_LIMIT, CODEX_DIFF_BASELINE_FILE_LIMIT = 200, CODEX_DIFF_BASELINE_BYTE_LIMIT, CODEX_STARTUP_TIMEOUT_MS = 90000;
 var init_codex_provider = __esm(async () => {
   init_codex_native_multi_agent();
   init_codex_tree_kill();
+  await init_codex_vault_hook_bridge();
   await init_execution_host();
   await init_codex();
   init_tool_format();
@@ -6468,7 +6617,7 @@ __export(exports_maestro_provider, {
   buildMaestroToolHooks: () => buildMaestroToolHooks,
   buildMaestroDisallowedTools: () => buildMaestroDisallowedTools
 });
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 import { maestroProvider as sdkMaestroProvider, setMcpResolver } from "maestro-agent-sdk";
 function buildMaestroDisallowedTools(callerDisallowedTools = [], toolPolicy) {
   return [
@@ -6602,13 +6751,13 @@ var init_maestro_provider = __esm(async () => {
     "ToolSearch",
     ...DEFAULT_MAESTRO_DISALLOWED_TOOLS
   ];
-  MAESTRO_TOOL_OUTPUT_DIR = resolve9(RUN_DIR, "maestro-tool-outputs");
+  MAESTRO_TOOL_OUTPUT_DIR = resolve10(RUN_DIR, "maestro-tool-outputs");
 });
 
 // ../../packages/core/src/agents/index.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function* dispatchAgent(opts) {
   switch (opts.agent) {
     case "claude": {
@@ -6642,11 +6791,11 @@ async function resolveSessionFileMissing(agent, sessionId, cwd) {
   switch (agent) {
     case "claude": {
       const encodedCwd = encodeClaudeCwd(cwd);
-      const path = join14(homedir8(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
-      return !existsSync14(path);
+      const path = join15(homedir8(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
+      return !existsSync15(path);
     }
     case "codex": {
-      const sessionsDir = join14(hostedCodexHomePath(), "sessions");
+      const sessionsDir = join15(hostedCodexHomePath(), "sessions");
       const glob = new Bun.Glob(`**/rollout-*-${sessionId}.jsonl`);
       for await (const _rel of glob.scan({ cwd: sessionsDir, onlyFiles: true })) {
         return false;
@@ -6655,7 +6804,7 @@ async function resolveSessionFileMissing(agent, sessionId, cwd) {
     }
     case "maestro": {
       const { hasActiveMaestroSession, maestroSessionPath: maestroSessionPath2 } = await import("maestro-agent-sdk");
-      return !existsSync14(maestroSessionPath2(sessionId)) && !hasActiveMaestroSession(sessionId);
+      return !existsSync15(maestroSessionPath2(sessionId)) && !hasActiveMaestroSession(sessionId);
     }
     default: {
       const _exhaustive = agent;
@@ -8874,7 +9023,7 @@ async function waitForRuntimeProcessLease(role, options = {}) {
     const remaining = deadline - Date.now();
     if (remaining <= 0)
       return null;
-    await new Promise((resolve10) => setTimeout(resolve10, Math.min(interval, remaining)));
+    await new Promise((resolve11) => setTimeout(resolve11, Math.min(interval, remaining)));
   }
 }
 async function waitForRequiredRuntimeProcessLease(role, options = {}) {
@@ -9151,8 +9300,8 @@ function createAskUserRuntime(host) {
       return errorResult(`Error: failed to persist ask_user_question: ${error instanceof Error ? error.message : String(error)}`);
     }
     let resolveAnswer;
-    const promise = new Promise((resolve10) => {
-      resolveAnswer = resolve10;
+    const promise = new Promise((resolve11) => {
+      resolveAnswer = resolve11;
     });
     pendingAsks.set(message.id, {
       topicId: ctx.topicId,
@@ -9808,11 +9957,11 @@ var init_manager_utils = () => {};
 // ../../packages/core/src/platform/playwright/browser-processes.ts
 import { execFileSync as execFileSync6 } from "child_process";
 import { readdirSync as readdirSync2, unlinkSync as unlinkSync10 } from "fs";
-import { createServer } from "net";
-import { resolve as resolve10, sep } from "path";
+import { createServer as createServer2 } from "net";
+import { resolve as resolve11, sep } from "path";
 function isPortInUse(port) {
   return new Promise((resolveProbe) => {
-    const server = createServer();
+    const server = createServer2();
     let settled = false;
     const finish = (occupied) => {
       if (settled)
@@ -9842,8 +9991,8 @@ async function reserveAvailableLoopbackPort(minPort, maxPort, reservedPorts, pro
   return null;
 }
 function killBrowserProcsForUserDataDir(userDataDir) {
-  const target = resolve10(userDataDir);
-  const profileRoot = resolve10(BROWSER_PROFILES_DIR);
+  const target = resolve11(userDataDir);
+  const profileRoot = resolve11(BROWSER_PROFILES_DIR);
   if (target !== profileRoot && !target.startsWith(`${profileRoot}${sep}`))
     return;
   let pids;
@@ -9864,7 +10013,7 @@ function killBrowserProcsForUserDataDir(userDataDir) {
         stdio: "pipe"
       }).toString().trim();
       const argDir = extractUserDataDirArg(cmdline);
-      if (!argDir || resolve10(argDir) !== target)
+      if (!argDir || resolve11(argDir) !== target)
         continue;
       killProcessTreeChildren(pidNum);
       process.kill(pidNum, "SIGKILL");
@@ -9875,13 +10024,13 @@ function killBrowserProcsForUserDataDir(userDataDir) {
   }
 }
 function selectOrphanBrowserPids(procs, liveUserDataDirs, profileRoot, selfPid) {
-  const root = resolve10(profileRoot);
-  const live = new Set([...liveUserDataDirs].map((d) => resolve10(d)));
+  const root = resolve11(profileRoot);
+  const live = new Set([...liveUserDataDirs].map((d) => resolve11(d)));
   const out = [];
   for (const { pid, userDataDir } of procs) {
     if (pid === selfPid || !userDataDir)
       continue;
-    const dir = resolve10(userDataDir);
+    const dir = resolve11(userDataDir);
     if (dir !== root && !dir.startsWith(`${root}${sep}`))
       continue;
     if (live.has(dir))
@@ -9897,7 +10046,7 @@ function reapOrphanBrowsers(liveUserDataDirs) {
   const daemonLease = getRuntimeProcessLease("node-daemon", Date.now(), Number.POSITIVE_INFINITY);
   if (!isBrowserJanitorOwner(daemonLease?.pid ?? null, process.pid))
     return;
-  const profileRoot = resolve10(BROWSER_PROFILES_DIR);
+  const profileRoot = resolve11(BROWSER_PROFILES_DIR);
   let pids;
   try {
     pids = execFileSync6("pgrep", ["-f", "--", profileRoot], { stdio: "pipe" }).toString().trim();
@@ -9936,7 +10085,7 @@ function cleanSingletonFiles(userDataDir) {
     for (const f of files) {
       if (f.startsWith("Singleton")) {
         try {
-          unlinkSync10(resolve10(userDataDir, f));
+          unlinkSync10(resolve11(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");
@@ -9976,9 +10125,9 @@ var init_browser_processes = __esm(async () => {
 
 // ../../packages/core/src/platform/playwright/headed-launch.ts
 import { accessSync as accessSync2, constants as constants2 } from "fs";
-import { delimiter, isAbsolute as isAbsolute3, resolve as resolve11 } from "path";
+import { delimiter, isAbsolute as isAbsolute3, resolve as resolve12 } from "path";
 function findExecutableOnPath(command, environment = process.env) {
-  const candidates = isAbsolute3(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => resolve11(directory, command));
+  const candidates = isAbsolute3(command) ? [command] : (environment.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => resolve12(directory, command));
   for (const candidate of candidates) {
     try {
       accessSync2(candidate, constants2.X_OK);
@@ -10099,11 +10248,11 @@ var init_vault_public = __esm(async () => {
 });
 
 // ../../packages/core/src/platform/playwright/vault-broker.ts
-import { randomBytes as randomBytes5, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { chmodSync as chmodSync4 } from "fs";
-import { createServer as createServer2 } from "net";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join15 } from "path";
+import { createServer as createServer3 } from "net";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join16 } from "path";
 function deepMapStrings2(value, transform) {
   if (typeof value === "string")
     return transform(value);
@@ -10189,8 +10338,8 @@ function authorized(actual, expected) {
   return left.length === right.length && timingSafeEqual2(left, right);
 }
 async function createBrowserVaultBroker(userId) {
-  const token = randomBytes5(32).toString("hex");
-  const socketPath = join15(process.platform === "win32" ? tmpdir2() : "/tmp", `negotium-browser-vault-${process.pid}-${randomBytes5(8).toString("hex")}.sock`);
+  const token = randomBytes6(32).toString("hex");
+  const socketPath = join16(process.platform === "win32" ? tmpdir3() : "/tmp", `negotium-browser-vault-${process.pid}-${randomBytes6(8).toString("hex")}.sock`);
   const retainedForms = new Map;
   const leases = new Map;
   const sockets = new Set;
@@ -10229,7 +10378,7 @@ async function createBrowserVaultBroker(userId) {
         return result.text;
       });
       const prepared = prepareInput(request.tool, substituted);
-      const lease = randomBytes5(24).toString("hex");
+      const lease = randomBytes6(24).toString("hex");
       leases.set(lease, { boundary: prepared.boundary, createdAt: Date.now() });
       return {
         id,
@@ -10261,7 +10410,7 @@ async function createBrowserVaultBroker(userId) {
     }
     return { id, ok: false, error: "unknown operation" };
   };
-  const server = createServer2((socket) => {
+  const server = createServer3((socket) => {
     sockets.add(socket);
     let pending = "";
     socket.setEncoding("utf8");
@@ -10446,24 +10595,24 @@ var init_browser_profiles = __esm(async () => {
 
 // ../../packages/core/src/platform/playwright/manager.ts
 import { execFileSync as execFileSync7, spawn as spawn5 } from "child_process";
-import { createHash as createHash4, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes7, timingSafeEqual as timingSafeEqual3 } from "crypto";
 import {
   cpSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync10,
   readFileSync as readFileSync12,
   rmSync as rmSync2,
   unlinkSync as unlinkSync11,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname10, join as join16, resolve as resolve12 } from "path";
+import { dirname as dirname11, join as join17, resolve as resolve13 } from "path";
 function removeDefaultProfileDataDir(userDataDir) {
-  const root = resolve12(BROWSER_PROFILES_DIR);
-  const target = resolve12(userDataDir);
-  if (dirname10(target) !== root) {
+  const root = resolve13(BROWSER_PROFILES_DIR);
+  const target = resolve13(userDataDir);
+  if (dirname11(target) !== root) {
     throw new Error(`Refusing to delete browser profile outside managed root: ${target}`);
   }
-  const existed = existsSync15(target);
+  const existed = existsSync16(target);
   rmSync2(target, { recursive: true, force: true });
   return existed;
 }
@@ -10546,14 +10695,14 @@ function portFileName(instanceKey) {
 function writePortFile(instanceKey, port) {
   try {
     mkdirSync10(managerHost.portsDir, { recursive: true });
-    writeFileSync8(join16(managerHost.portsDir, portFileName(instanceKey)), String(port));
+    writeFileSync8(join17(managerHost.portsDir, portFileName(instanceKey)), String(port));
   } catch (e) {
     logger.warn({ err: e, instanceKey, port }, "Failed to save playwright port file");
   }
 }
 function deletePortFile(instanceKey) {
   try {
-    unlinkSync11(join16(managerHost.portsDir, portFileName(instanceKey)));
+    unlinkSync11(join17(managerHost.portsDir, portFileName(instanceKey)));
   } catch (e) {
     if (e.code === "ENOENT")
       return;
@@ -10700,7 +10849,7 @@ function releasePort(port) {
   usedPorts.delete(port);
 }
 function defaultProfileDir(_ownerId, profile) {
-  return resolve12(BROWSER_PROFILES_DIR, profile);
+  return resolve13(BROWSER_PROFILES_DIR, profile);
 }
 function resolveUserDataDir(instanceKey) {
   return managerHost.resolveInstanceDataDir(instanceKey);
@@ -10792,8 +10941,8 @@ async function spawnPlaywright(instanceKey, ownerId, reservedPort, browserBin =
     releasePort(port);
     throw new Error("Browser.rs managed mode does not support authenticated egress proxies");
   }
-  const capability = randomBytes6(32).toString("hex");
-  const spawnNonce = randomBytes6(32).toString("hex");
+  const capability = randomBytes7(32).toString("hex");
+  const spawnNonce = randomBytes7(32).toString("hex");
   let vaultBroker;
   try {
     vaultBroker = await createBrowserVaultBroker(ownerId);
@@ -11061,14 +11210,14 @@ async function cloneProfileForChild(opts) {
       killInstance(dstKey);
       await delay(500);
     }
-    if (!existsSync15(srcDir)) {
+    if (!existsSync16(srcDir)) {
       return { copied: false, srcDir, dstDir, reason: "src-missing" };
     }
     try {
-      if (existsSync15(dstDir)) {
+      if (existsSync16(dstDir)) {
         rmSync2(dstDir, { recursive: true, force: true });
       }
-      mkdirSync10(dirname10(dstDir), { recursive: true });
+      mkdirSync10(dirname11(dstDir), { recursive: true });
       if (process.platform === "darwin") {
         try {
           execFileSync7("cp", ["-cR", srcDir, dstDir], { stdio: "pipe" });
@@ -11086,7 +11235,7 @@ async function cloneProfileForChild(opts) {
     cleanSingletonFiles(dstDir);
     for (const f of ["DevToolsActivePort", "LOCK"]) {
       try {
-        unlinkSync11(resolve12(dstDir, f));
+        unlinkSync11(resolve13(dstDir, f));
       } catch {}
     }
     logger.info({ srcKey, dstKey, srcDir, dstDir }, "Cloned Playwright profile for child topic");
@@ -11589,9 +11738,9 @@ var init_personal_general = __esm(async () => {
 
 // ../../packages/core/src/prompts/builders.ts
 import { readFileSync as readFileSync13 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 function loadPrompt(filename, dir = SESSIONS_DIR) {
-  const raw = readFileSync13(resolve13(dir, filename), "utf-8");
+  const raw = readFileSync13(resolve14(dir, filename), "utf-8");
   return raw.replace(/\{\{RESOURCES_DIR\}\}/g, RESOURCES_DIR);
 }
 function replaceVars(template, vars) {
@@ -11640,7 +11789,7 @@ function visualDesignGuide() {
   return _visualDesignGuide;
 }
 function loadAgentPrompt(filename) {
-  const raw = readFileSync13(resolve13(AGENTS_PROMPTS_DIR, filename), "utf-8");
+  const raw = readFileSync13(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`);
@@ -11955,8 +12104,8 @@ var init_builders = __esm(() => {
   init_model_catalog();
   init_config();
   init_logger();
-  PROMPTS_DIR = resolve13(PROJECT_ROOT, "src/prompts");
-  SESSIONS_DIR = resolve13(PROMPTS_DIR, "sessions");
+  PROMPTS_DIR = resolve14(PROJECT_ROOT, "src/prompts");
+  SESSIONS_DIR = resolve14(PROMPTS_DIR, "sessions");
   defaultPromptBuilders = createPromptBuilders();
   buildTopicSystemPrompt = defaultPromptBuilders.buildTopicSystemPrompt;
   buildChannelSystemPrompt = defaultPromptBuilders.buildChannelSystemPrompt;
@@ -12098,50 +12247,50 @@ __export(exports_wiki, {
   getTopicMemoryFilePaths: () => getTopicMemoryFilePaths,
   getSharedWikiDir: () => getSharedWikiDir
 });
-import { existsSync as existsSync16, readdirSync as readdirSync3, statSync as statSync6 } from "fs";
-import { basename as basename2, dirname as dirname11, join as join17 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync3, statSync as statSync6 } from "fs";
+import { basename as basename2, dirname as dirname12, join as join18 } from "path";
 function getWikiDir(_userId, workspaceDir = resolveStorageWorkspaceDir()) {
-  return join17(workspaceDir, "wiki");
+  return join18(workspaceDir, "wiki");
 }
 function getSharedWikiDir(workspaceDir = resolveStorageWorkspaceDir()) {
-  return workspaceDir === resolveStorageWorkspaceDir() ? resolveStorageSharedWikiDir() : join17(workspaceDir, "wiki");
+  return workspaceDir === resolveStorageWorkspaceDir() ? resolveStorageSharedWikiDir() : join18(workspaceDir, "wiki");
 }
 function findLatestSummaryFile(wikiDir, safeTopic) {
-  const summariesDir = join17(wikiDir, "summaries");
-  if (!existsSync16(summariesDir))
+  const summariesDir = join18(wikiDir, "summaries");
+  if (!existsSync17(summariesDir))
     return null;
   const files = readdirSync3(summariesDir).filter((f) => f.endsWith(".md") && f.match(new RegExp(`^\\d{4}-\\d{2}-\\d{2}-${safeTopic}(\\.md|~\\d+\\.md)$`)) && !f.endsWith("-sent-files.md")).sort((left, right) => {
-    const mtimeDelta = statSync6(join17(summariesDir, right)).mtimeMs - statSync6(join17(summariesDir, left)).mtimeMs;
+    const mtimeDelta = statSync6(join18(summariesDir, right)).mtimeMs - statSync6(join18(summariesDir, left)).mtimeMs;
     return mtimeDelta || right.localeCompare(left, undefined, { numeric: true });
   });
-  return files.length > 0 ? join17(summariesDir, files[0]) : null;
+  return files.length > 0 ? join18(summariesDir, files[0]) : null;
 }
 function getTopicMemoryFilePaths(_userId, topicName, forkOrigin, workspaceDir = resolveStorageWorkspaceDir()) {
   const wikiDir = getSharedWikiDir(workspaceDir);
   const resolveBrief = (name) => {
     const safe = sanitizeTopicName(name, true);
-    const brief = join17(wikiDir, "topic", `${safe}.md`);
+    const brief = join18(wikiDir, "topic", `${safe}.md`);
     const latestSummary = findLatestSummaryFile(wikiDir, safe);
     return { brief, latestSummary };
   };
-  const archiveDir = join17(wikiDir, "archive");
+  const archiveDir = join18(wikiDir, "archive");
   const archiveExistsFor = (name) => {
     const safe = sanitizeTopicName(name);
-    return existsSync16(archiveDir) && readdirSync3(archiveDir).some((f) => f.endsWith(".jsonl") && f.startsWith(`${safe}_`));
+    return existsSync17(archiveDir) && readdirSync3(archiveDir).some((f) => f.endsWith(".jsonl") && f.startsWith(`${safe}_`));
   };
   const sourceTopic = forkOrigin ?? topicName;
   const hasArchive = archiveExistsFor(sourceTopic) || (forkOrigin ? archiveExistsFor(topicName) : false);
   const target = resolveBrief(sourceTopic);
-  if (existsSync16(target.brief)) {
+  if (existsSync17(target.brief)) {
     return {
-      memoryDir: dirname11(target.brief),
+      memoryDir: dirname12(target.brief),
       memoryFiles: [basename2(target.brief)],
       ...target.latestSummary ? { latestSummaryFile: target.latestSummary } : {},
       ...hasArchive ? { hasArchive: true } : {}
     };
   }
   return {
-    memoryDir: join17(wikiDir, "topic"),
+    memoryDir: join18(wikiDir, "topic"),
     memoryFiles: [],
     ...target.latestSummary ? { latestSummaryFile: target.latestSummary } : {},
     ...hasArchive ? { hasArchive: true } : {}
@@ -12153,8 +12302,8 @@ var init_wiki = __esm(async () => {
 
 // ../../packages/core/src/agents/archiver.ts
 import { randomUUID as randomUUID10 } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync14, statSync as statSync7 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync4, readFileSync as readFileSync14, statSync as statSync7 } from "fs";
+import { join as join19 } from "path";
 function resolveMemoryLanguage() {
   const override = process.env.NEGOTIUM_MEMORY_LANG?.trim();
   return override && override.length > 0 ? override : resolveOutputLanguage();
@@ -12405,10 +12554,10 @@ function distillOneLine(summaryMd) {
   return "";
 }
 function findSummaryFile(storage, topicTitle, date, sinceMs, topicId) {
-  const dir = join18(storage.getWikiDir(), "summaries");
+  const dir = join19(storage.getWikiDir(), "summaries");
   if (!storage.fileExists(dir))
     return null;
-  const predicted = join18(dir, wikiSummaryFilename(date, topicTitle, topicId));
+  const predicted = join19(dir, wikiSummaryFilename(date, topicTitle, topicId));
   if (storage.fileExists(predicted) && storage.fileModifiedAt(predicted) >= sinceMs)
     return predicted;
   let best = null;
@@ -12416,7 +12565,7 @@ function findSummaryFile(storage, topicTitle, date, sinceMs, topicId) {
     if (!f.startsWith(`${date}-`) || !isTopicSummaryFile(f, topicId ?? "", topicTitle)) {
       continue;
     }
-    const p = join18(dir, f);
+    const p = join19(dir, f);
     try {
       const m = storage.fileModifiedAt(p);
       if (m >= sinceMs && (!best || m > best.mtime))
@@ -12500,7 +12649,7 @@ var init_archiver = __esm(async () => {
   defaultArchiverRuntime = createArchiverRuntime({
     storage: {
       getWikiDir: getSharedWikiDir,
-      fileExists: existsSync17,
+      fileExists: existsSync18,
       listDirectory: readdirSync4,
       readTextFile: (path) => readFileSync14(path, "utf-8"),
       fileSize: (path) => statSync7(path).size,
@@ -12632,13 +12781,13 @@ __export(exports_topic_archive, {
   archiveConversationEvents: () => archiveConversationEvents
 });
 import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync9 } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function archiveTopicMessages(topicId, topicTitle, options = {}) {
   const rows = options.afterRowid !== undefined ? getMessagesForTopicAfterRowid(topicId, options.afterRowid) : getAllMessagesForTopic(topicId);
   if (rows.length === 0)
     return null;
   const safeTopic = sanitizeTopicName(topicTitle, true);
-  const archiveDir = join19(getSharedWikiDir(), "archive");
+  const archiveDir = join20(getSharedWikiDir(), "archive");
   mkdirSync11(archiveDir, { recursive: true });
   const date = new Date().toISOString().slice(0, 10);
   const reasonSuffix = options.reason && options.reason !== "delete" ? `_${options.reason}` : "";
@@ -12651,7 +12800,7 @@ function archiveTopicMessages(topicId, topicTitle, options = {}) {
   let path;
   while (true) {
     filename = `${safeTopic}_${date}${reasonSuffix}${counter === 1 ? "" : `_${counter}`}.jsonl`;
-    path = join19(archiveDir, filename);
+    path = join20(archiveDir, filename);
     try {
       writeFileSync9(path, body, { flag: "wx" });
       break;
@@ -12696,7 +12845,7 @@ function archiveConversationEvents(topicId, topicTitle, userId, options = {}) {
   const entries = readRawConversation(userId, topicTitle);
   if (entries.length === 0)
     return null;
-  const archiveDir = join19(getSharedWikiDir(), "archive");
+  const archiveDir = join20(getSharedWikiDir(), "archive");
   mkdirSync11(archiveDir, { recursive: true });
   const safeTopic = sanitizeTopicName(topicTitle, true);
   const date = new Date().toISOString().slice(0, 10);
@@ -12724,7 +12873,7 @@ function archiveConversationEvents(topicId, topicTitle, userId, options = {}) {
   let counter = 1;
   while (true) {
     const suffix = counter === 1 ? "" : `_${counter}`;
-    const path = join19(archiveDir, `${safeTopic}_${date}${reasonSuffix}_events${suffix}.jsonl`);
+    const path = join20(archiveDir, `${safeTopic}_${date}${reasonSuffix}_events${suffix}.jsonl`);
     try {
       writeFileSync9(path, body, { flag: "wx" });
       logger.info({ topicId, topicTitle, archive: path, eventCount: entries.length }, "archiveConversationEvents: archived raw conversation events");
@@ -13051,7 +13200,7 @@ var init_idle_archiver = __esm(async () => {
 
 // ../../packages/core/src/agents/topic-cleanup.ts
 import { mkdirSync as mkdirSync12, renameSync as renameSync6, unlinkSync as unlinkSync12, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 function collectSessionIdsByAgent(entries, extraSessions = []) {
   const out = new Map;
   for (const e of entries) {
@@ -13117,7 +13266,7 @@ function createTopicLogMaintenance(host) {
       const path = runtimeHost.activeConversationPath(opts.userId, opts.topicName);
       const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
       try {
-        mkdirSync12(dirname12(path), { recursive: true });
+        mkdirSync12(dirname13(path), { recursive: true });
         writeFileSync10(tempPath, retained.length > 0 ? `${retained.map((entry) => JSON.stringify(entry)).join(`
 `)}
 ` : "", { flag: "wx" });
@@ -13734,15 +13883,15 @@ var init_runtime_turn_requests = __esm(async () => {
 // ../../packages/core/src/topics/session.ts
 import { randomUUID as randomUUID11 } from "crypto";
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
-import { tmpdir as tmpdir3 } from "os";
-import { join as join20 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join21 } from "path";
 async function waitForMemoryArchive(settled, timeoutMs) {
   let timer;
   try {
     return await Promise.race([
       settled.then(() => true),
-      new Promise((resolve14) => {
-        timer = setTimeout(() => resolve14(false), timeoutMs);
+      new Promise((resolve15) => {
+        timer = setTimeout(() => resolve15(false), timeoutMs);
         timer.unref?.();
       })
     ]);
@@ -13806,8 +13955,8 @@ async function restartTopicSession(topicId, userId, reason = "topic-session-rest
       };
     }
     let settleMemoryArchive;
-    const memoryArchiveSettled = new Promise((resolve14) => {
-      settleMemoryArchive = resolve14;
+    const memoryArchiveSettled = new Promise((resolve15) => {
+      settleMemoryArchive = resolve15;
     });
     const archiveStatus = (options.archiveMemory ?? archiveActiveTopicForMemory)(topicId, userId, {
       reason: "reset",
@@ -13988,7 +14137,7 @@ function formatCompactElapsed(startedAt) {
 async function summarizeTopicContext(request) {
   const startedAt = Date.now();
   const sessionIds = [];
-  const compactCwd = mkdtempSync2(join20(tmpdir3(), "negotium-compact-"));
+  const compactCwd = mkdtempSync2(join21(tmpdir4(), "negotium-compact-"));
   const abortController = new AbortController;
   const relayAbort = () => abortController.abort(request.signal?.reason);
   if (request.signal?.aborted)
@@ -14015,7 +14164,7 @@ async function summarizeTopicContext(request) {
   let error = "";
   let toolViolation = false;
   let compactionLogCalls = 0;
-  const compactionLogPath = join20(compactCwd, "conversation.log");
+  const compactionLogPath = join21(compactCwd, "conversation.log");
   try {
     const compactionMcp = useCompactionLog ? {
       compact_log: {
@@ -15336,14 +15485,14 @@ var init_self_config = __esm(async () => {
 });
 
 // ../../packages/core/src/query/session-inbox-path.ts
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function sessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join21(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
+  return join22(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${JSONL_SUFFIX}`);
 }
 function scheduledSessionInboxPath(userId, topicId) {
   const key = Buffer.from(topicId, "utf8").toString("base64url");
-  return join21(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
+  return join22(SESSION_INBOX_DIR, userId, `${TOPIC_ID_FILE_PREFIX}${key}${SCHEDULE_SUFFIX}`);
 }
 function decodeTopicIdFileName(fileName, suffix) {
   if (!fileName.startsWith(TOPIC_ID_FILE_PREFIX) || !fileName.endsWith(suffix))
@@ -15371,13 +15520,13 @@ var init_session_inbox_path = __esm(() => {
 
 // ../../packages/core/src/query/session-inbox-cleanup.ts
 import { unlinkSync as unlinkSync14 } from "fs";
-import { basename as basename3, join as join22 } from "path";
+import { basename as basename3, join as join23 } from "path";
 function cleanupSessionInboxFiles(userId, topicId, legacyTopicTitle) {
   const live = sessionInboxPath(userId, topicId);
   const scheduled = scheduledSessionInboxPath(userId, topicId);
   const candidates = new Set([live, `${live}.processing`, scheduled, `${scheduled}.processing`]);
   if (legacyTopicTitle && legacyTopicTitle !== "." && legacyTopicTitle !== ".." && basename3(legacyTopicTitle) === legacyTopicTitle) {
-    const legacyBase = join22(SESSION_INBOX_DIR, userId, legacyTopicTitle);
+    const legacyBase = join23(SESSION_INBOX_DIR, userId, legacyTopicTitle);
     for (const suffix of [".jsonl", ".jsonl.processing", ".schedule", ".schedule.processing"]) {
       candidates.add(`${legacyBase}${suffix}`);
     }
@@ -15403,16 +15552,16 @@ var init_session_inbox_cleanup = __esm(() => {
 
 // ../../packages/core/src/query/state.ts
 import { mkdirSync as mkdirSync14, renameSync as renameSync7, unlinkSync as unlinkSync15, writeFileSync as writeFileSync12 } from "fs";
-import { basename as basename4, join as join23 } from "path";
+import { basename as basename4, join as join24 } from "path";
 function createQueryStateStore(options) {
   const sanitize = options.sanitizeTopicId ?? sanitizeId;
-  const queryStateDirPath = (userId) => join23(options.usersLogDir, String(userId), "active-queries");
-  const queryStateFile = (userId, topicId) => join23(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
+  const queryStateDirPath = (userId) => join24(options.usersLogDir, String(userId), "active-queries");
+  const queryStateFile = (userId, topicId) => join24(queryStateDirPath(userId), `${sanitize(topicId)}.json`);
   const legacyQueryStateFile = (userId, topicName) => {
     if (!topicName || topicName === "." || topicName === ".." || basename4(topicName) !== topicName) {
       return null;
     }
-    return join23(queryStateDirPath(userId), `${topicName}.json`);
+    return join24(queryStateDirPath(userId), `${topicName}.json`);
   };
   return {
     write(userId, topicId, topicName, task) {
@@ -15573,30 +15722,30 @@ import {
   unlinkSync as unlinkSync16,
   writeFileSync as writeFileSync13
 } from "fs";
-import { dirname as dirname13, join as join24 } from "path";
+import { dirname as dirname14, join as join25 } from "path";
 function pendingAskDir(userId) {
   const rawUserId = String(userId);
   const safeUserId = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,255}$/.test(rawUserId) && !rawUserId.includes("..") ? rawUserId : `sha256-${createHash6("sha256").update(rawUserId).digest("hex")}`;
-  return join24(resolveStorageSessionAsksDir(), safeUserId);
+  return join25(resolveStorageSessionAsksDir(), safeUserId);
 }
 function encodeAskKey(key) {
   return JSON.stringify([key.from, key.to]);
 }
 function pendingAskPath(key) {
   const digest = createHash6("sha256").update(encodeAskKey(key)).digest("hex");
-  return join24(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest}.pending`);
+  return join25(pendingAskDir(key.userId), `${ASK_FILENAME_PREFIX}${digest}.pending`);
 }
 function v2PendingAskPath(key) {
   const encoded = Buffer.from(encodeAskKey(key), "utf8").toString("base64url");
-  return join24(pendingAskDir(key.userId), `${V2_ASK_FILENAME_PREFIX}${encoded}.pending`);
+  return join25(pendingAskDir(key.userId), `${V2_ASK_FILENAME_PREFIX}${encoded}.pending`);
 }
 function legacyPendingAskPath(key) {
   if (key.from.includes("/") || key.from.includes("\\") || key.to.includes("/") || key.to.includes("\\") || key.from.includes("\x00") || key.to.includes("\x00")) {
     return null;
   }
   const dir = pendingAskDir(key.userId);
-  const candidate = join24(dir, `${key.from}___${key.to}.pending`);
-  return dirname13(candidate) === dir ? candidate : null;
+  const candidate = join25(dir, `${key.from}___${key.to}.pending`);
+  return dirname14(candidate) === dir ? candidate : null;
 }
 function parsePendingAskFilename(fileName) {
   if (!fileName.endsWith(".pending"))
@@ -15836,7 +15985,7 @@ function listPendingAsksForCaller(args) {
     const parsed = isV3 ? { from: args.from, to: "" } : parsePendingAskFilename(fileName);
     if (!parsed)
       continue;
-    const path = join24(dir, fileName);
+    const path = join25(dir, fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
       from: parsed.from,
@@ -15878,7 +16027,7 @@ function deletePendingAsksForTopic(args) {
   }
   let deleted = 0;
   for (const fileName of files) {
-    const path = join24(dir, fileName);
+    const path = join25(dir, fileName);
     const parsed = parsePendingAskFilename(fileName);
     const record = readPendingAskFile(path, {
       userId: args.userId,
@@ -16296,7 +16445,7 @@ __export(exports_token_stats, {
 });
 import { createHash as createHash7 } from "crypto";
 import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function emptyBucket() {
   return {
     inputTokens: 0,
@@ -16315,7 +16464,7 @@ function queriesPath(userId) {
   const fileId = tokenStatsFileId(userId);
   const logDir = resolveStorageLogDir();
   mkdirSync16(logDir, { recursive: true });
-  return join25(logDir, `token-queries-${fileId}.jsonl`);
+  return join26(logDir, `token-queries-${fileId}.jsonl`);
 }
 function loadRecords(userId) {
   try {
@@ -16744,7 +16893,7 @@ var init_lifecycle = __esm(async () => {
 // ../../packages/core/src/runtime/attachments.ts
 import { randomUUID as randomUUID14 } from "crypto";
 import { copyFileSync as copyFileSync2, mkdirSync as mkdirSync17, writeFileSync as writeFileSync15 } from "fs";
-import { basename as basename5, join as join26 } from "path";
+import { basename as basename5, join as join27 } from "path";
 function workspaceCwdFor(topicId) {
   return resolveTopicWorkspaceDir(topicId);
 }
@@ -16757,7 +16906,7 @@ function materializePromptAttachments(topicId, queryId, attachmentIds) {
   if (!attachmentIds?.length)
     return [];
   const out = [];
-  const destDir = join26(workspaceCwdFor(topicId), "attachments", queryId);
+  const destDir = join27(workspaceCwdFor(topicId), "attachments", queryId);
   for (const rawId of attachmentIds) {
     if (typeof rawId !== "string")
       continue;
@@ -16774,7 +16923,7 @@ function materializePromptAttachments(topicId, queryId, attachmentIds) {
       mkdirSync17(destDir, { recursive: true });
       const index = String(out.length + 1).padStart(2, "0");
       const safeName = safeAttachmentFilename(attachment.filename, fileId);
-      const destPath = join26(destDir, `${index}-${fileId.slice(0, 8)}-${safeName}`);
+      const destPath = join27(destDir, `${index}-${fileId.slice(0, 8)}-${safeName}`);
       copyFileSync2(sourcePath, destPath);
       out.push({
         id: attachment.id,
@@ -16804,10 +16953,10 @@ function promptWithAttachments(prompt, attachments) {
   return composeAttachmentPrompt(prompt, attachments.map(({ filename, path }) => attachmentPromptLine(filename, path)));
 }
 function ingestAttachment(args) {
-  const destDir = join26(UPLOADS_DIR, args.topicId);
+  const destDir = join27(UPLOADS_DIR, args.topicId);
   mkdirSync17(destDir, { recursive: true });
   const safeName = safeAttachmentFilename(args.filename, "upload");
-  const destPath = join26(destDir, `${Date.now()}-${randomUUID14().slice(0, 8)}-${safeName}`);
+  const destPath = join27(destDir, `${Date.now()}-${randomUUID14().slice(0, 8)}-${safeName}`);
   if (args.sourcePath !== undefined) {
     copyFileSync2(args.sourcePath, destPath);
   } else if (args.bytes !== undefined) {
@@ -16982,12 +17131,12 @@ var init_errors = __esm(() => {
 
 // ../../packages/core/src/runtime/event-heartbeat.ts
 function nextOrHeartbeat(pending, intervalMs) {
-  return new Promise((resolve14, reject) => {
-    const timer = setTimeout(() => resolve14({ kind: "heartbeat" }), intervalMs);
+  return new Promise((resolve15, reject) => {
+    const timer = setTimeout(() => resolve15({ kind: "heartbeat" }), intervalMs);
     timer.unref?.();
     pending.then((result) => {
       clearTimeout(timer);
-      resolve14({ kind: "event", result });
+      resolve15({ kind: "event", result });
     }, (error) => {
       clearTimeout(timer);
       reject(error);
@@ -17324,7 +17473,7 @@ var init_visual_html = __esm(() => {
 
 // ../../packages/core/src/runtime/visuals.ts
 import { realpathSync as realpathSync4 } from "fs";
-import { isAbsolute as isAbsolute4, resolve as resolve14 } from "path";
+import { isAbsolute as isAbsolute4, resolve as resolve15 } from "path";
 function activeVisualHtmlForPrompt(html) {
   if (html.length <= ACTIVE_VISUAL_PROMPT_MAX_CHARS) {
     return { html, omittedChars: 0 };
@@ -17375,8 +17524,8 @@ function topicAllowsVisualFileId(topicId, fileId) {
   return topicHasAttachmentFileId(topicId, fileId) || topicHasVisualFileId(topicId, fileId);
 }
 function isPathInside(baseDir, filePath) {
-  const base = resolve14(baseDir);
-  const normalized = resolve14(filePath);
+  const base = resolve15(baseDir);
+  const normalized = resolve15(filePath);
   try {
     const realBase = realpathSync4(base);
     const real = realpathSync4(normalized);
@@ -17438,7 +17587,7 @@ function resolveVisualMediaInput(topicId, input) {
   }
   const rawPath = input.file_path.trim();
   const cwd = workspaceCwdFor(topicId);
-  const candidate = isAbsolute4(rawPath) ? rawPath : resolve14(cwd, rawPath);
+  const candidate = isAbsolute4(rawPath) ? rawPath : resolve15(cwd, rawPath);
   if (!isPathInside(cwd, candidate)) {
     return { error: "file_path must be inside the topic workspace" };
   }
@@ -17476,7 +17625,7 @@ var init_visuals = __esm(async () => {
 // ../../packages/core/src/runtime/turn-event-stream.ts
 import { randomUUID as randomUUID15 } from "crypto";
 import { realpathSync as realpathSync5, statSync as statSync9 } from "fs";
-import { isAbsolute as isAbsolute5, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute5, resolve as resolve16 } from "path";
 function sessionEventMatchesCurrentExecution(topicId, queryId, agent, model) {
   if (getRoomQuery(topicId)?.queryId !== queryId)
     return false;
@@ -17829,7 +17978,7 @@ ${JSON.stringify(event.input ?? {})}`);
         case "file":
           if (!silent && peerBridge) {
             const cwd = workspaceCwdFor(topicId);
-            const path = isAbsolute5(event.path) ? event.path : resolve15(cwd, event.path);
+            const path = isAbsolute5(event.path) ? event.path : resolve16(cwd, event.path);
             if (!isPathInside(cwd, path)) {
               logger.warn({ topicId, path }, "peer output file is outside the topic workspace");
               break;
@@ -18117,15 +18266,15 @@ __export(exports_app_settings, {
   getGlobalAiName: () => getGlobalAiName,
   DEFAULT_AI_NAME: () => DEFAULT_AI_NAME
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync16 } from "fs";
-import { dirname as dirname14, join as join27 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname15, join as join28 } from "path";
 function settingsFile() {
-  return join27(resolveStorageDataDir(), "otium-settings.json");
+  return join28(resolveStorageDataDir(), "otium-settings.json");
 }
 function getGlobalAiName() {
   const path = settingsFile();
   try {
-    if (existsSync18(path)) {
+    if (existsSync19(path)) {
       const data = JSON.parse(readFileSync16(path, "utf8"));
       if (typeof data.aiName === "string" && data.aiName.trim()) {
         return data.aiName.trim();
@@ -18138,7 +18287,7 @@ function setGlobalAiName(name) {
   const path = settingsFile();
   const aiName = name.trim() || DEFAULT_AI_NAME;
   try {
-    mkdirSync18(dirname14(path), { recursive: true });
+    mkdirSync18(dirname15(path), { recursive: true });
     writeFileSync16(path, JSON.stringify({ aiName }, null, 2));
   } catch {}
   return aiName;
@@ -18223,8 +18372,8 @@ __export(exports_turn_runner, {
   AGENT_DISPLAY_NAME: () => AGENT_DISPLAY_NAME
 });
 import { randomUUID as randomUUID16 } from "crypto";
-import { existsSync as existsSync19, mkdirSync as mkdirSync19, readdirSync as readdirSync6, statSync as statSync10 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync19, readdirSync as readdirSync6, statSync as statSync10 } from "fs";
+import { join as join29 } from "path";
 function withDefaultPlaywright(configuredMcp, isManager) {
   if (isManager)
     return configuredMcp;
@@ -18279,8 +18428,8 @@ function appendAskReplyMessage(topicId, text2, agentType) {
   return message;
 }
 function resolveWikiMirrorPath(directory, preferredFilename, matchesLegacyId, matchesTitle, preferExact = true) {
-  const preferred = join28(directory, preferredFilename);
-  if (preferExact && existsSync19(preferred))
+  const preferred = join29(directory, preferredFilename);
+  if (preferExact && existsSync20(preferred))
     return preferred;
   let newestLegacyId = null;
   let newestTitle = null;
@@ -18290,7 +18439,7 @@ function resolveWikiMirrorPath(directory, preferredFilename, matchesLegacyId, ma
       const legacyIdMatch = !titleMatch && matchesLegacyId(filename);
       if (!titleMatch && !legacyIdMatch)
         continue;
-      const path = join28(directory, filename);
+      const path = join29(directory, filename);
       const mtimeMs = statSync10(path).mtimeMs;
       if (titleMatch) {
         if (!newestTitle || mtimeMs > newestTitle.mtimeMs) {
@@ -18304,10 +18453,10 @@ function resolveWikiMirrorPath(directory, preferredFilename, matchesLegacyId, ma
   return newestTitle?.path ?? newestLegacyId?.path ?? preferred;
 }
 function resolveWikiMemoryMirror(wikiDir, topicId, topicTitle) {
-  const briefFile = resolveWikiMirrorPath(join28(wikiDir, "topic"), `${wikiBriefStorageKey(topicTitle, topicId)}.md`, (filename) => isTopicBriefFile(filename, topicId), (filename) => isTopicBriefFile(filename, topicId, topicTitle));
-  const hasBriefFile = existsSync19(briefFile) && statSync10(briefFile).isFile();
-  const latestSummaryCandidate = resolveWikiMirrorPath(join28(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 briefFile = resolveWikiMirrorPath(join29(wikiDir, "topic"), `${wikiBriefStorageKey(topicTitle, topicId)}.md`, (filename) => isTopicBriefFile(filename, topicId), (filename) => isTopicBriefFile(filename, topicId, topicTitle));
+  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 = 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) {
@@ -21054,9 +21203,9 @@ var init_vault_command = __esm(async () => {
 
 // ../../packages/core/src/media/text-extractor.ts
 import { execFile } from "child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync21, readFileSync as readFileSync17, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync21, readFileSync as readFileSync17, rmSync as rmSync7 } from "fs";
 import { readFile } from "fs/promises";
-import { extname, join as join29 } from "path";
+import { extname, join as join30 } from "path";
 import { promisify } from "util";
 async function extractText(filePath) {
   const ext = extname(filePath).toLowerCase();
@@ -21161,7 +21310,7 @@ async function extractFromImage(filePath) {
 function isTranscriptionConfigured(opts = {}) {
   const ffmpeg = opts.ffmpegBin ?? FFMPEG_BIN;
   const wrapper = opts.wrapperPath ?? FASTER_WHISPER_WRAPPER;
-  return Boolean(ffmpeg) && existsSync20(wrapper);
+  return Boolean(ffmpeg) && existsSync21(wrapper);
 }
 async function transcribeAudio(filePath, opts = {}) {
   if (!isTranscriptionConfigured(opts))
@@ -21173,7 +21322,7 @@ async function extractFromAudio(filePath, opts = {}) {
   const tmpDir = `${filePath}_whisper_tmp`;
   try {
     mkdirSync21(tmpDir, { recursive: true });
-    const mp3Path = join29(tmpDir, "audio.mp3");
+    const mp3Path = join30(tmpDir, "audio.mp3");
     await execFileAsync(opts.ffmpegBin ?? FFMPEG_BIN2, [
       "-y",
       "-i",
@@ -21200,8 +21349,8 @@ async function extractFromAudio(filePath, opts = {}) {
       "--output-format",
       "txt"
     ], { timeout: 120000 });
-    const txtPath = join29(tmpDir, "audio.txt");
-    const text2 = existsSync20(txtPath) ? readFileSync17(txtPath, "utf-8").trim() : null;
+    const txtPath = join30(tmpDir, "audio.txt");
+    const text2 = existsSync21(txtPath) ? readFileSync17(txtPath, "utf-8").trim() : null;
     if (!text2) {
       return { text: null, method: "whisper", error: "Whisper produced no text" };
     }
@@ -21372,19 +21521,19 @@ var init_lifecycle2 = __esm(() => {
 });
 
 // ../../packages/core/src/platform/log-rotation.ts
-import { existsSync as existsSync21, renameSync as renameSync8, statSync as statSync11 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync22, renameSync as renameSync8, statSync as statSync11 } from "fs";
+import { join as join31 } from "path";
 function rotateOversizedLog(logPath, maxBytes = DEFAULT_DAEMON_LOG_ROTATE_BYTES) {
   try {
-    if (!existsSync21(logPath))
+    if (!existsSync22(logPath))
       return;
     const { size } = statSync11(logPath);
     if (size < maxBytes)
       return;
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-    const dir = join30(logPath, "..");
+    const dir = join31(logPath, "..");
     const base = logPath.slice(dir.length + 1);
-    renameSync8(logPath, join30(dir, `${base}.${stamp}`));
+    renameSync8(logPath, join31(dir, `${base}.${stamp}`));
   } catch {}
 }
 var DEFAULT_DAEMON_LOG_ROTATE_BYTES;
@@ -21577,7 +21726,7 @@ import {
   rmSync as rmSync8,
   statSync as statSync12
 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 function setBashrsCompletionSink(sink) {
   completionSink = sink ?? defaultSink;
 }
@@ -21604,15 +21753,15 @@ function readTail(filePath) {
   }
 }
 function buildMessage(dir, result) {
-  const stdout = readTail(join31(dir, "stdout.log"));
-  const stderr = readTail(join31(dir, "stderr.log"));
+  const stdout = readTail(join32(dir, "stdout.log"));
+  const stderr = readTail(join32(dir, "stderr.log"));
   const parts = [];
   if (stdout.text.trim() || stdout.truncated) {
-    parts.push(`stdout${stdout.truncated ? ` (truncated, full output: ${join31(dir, "stdout.log")})` : ""}:
+    parts.push(`stdout${stdout.truncated ? ` (truncated, full output: ${join32(dir, "stdout.log")})` : ""}:
 ${stdout.text.trim()}`);
   }
   if (stderr.text.trim() || stderr.truncated) {
-    parts.push(`stderr${stderr.truncated ? ` (truncated, full output: ${join31(dir, "stderr.log")})` : ""}:
+    parts.push(`stderr${stderr.truncated ? ` (truncated, full output: ${join32(dir, "stderr.log")})` : ""}:
 ${stderr.text.trim()}`);
   }
   const header = watchHeader(result) ?? `[background_bash ${result.bash_id} finished]`;
@@ -21646,7 +21795,7 @@ function parseOwner(owner) {
   return { userId, topicId };
 }
 function injectedMarker(dir) {
-  return join31(dir, "result.json.injected");
+  return join32(dir, "result.json.injected");
 }
 async function flushBashrsCompletions() {
   let entries;
@@ -21657,8 +21806,8 @@ async function flushBashrsCompletions() {
   }
   const now = Date.now();
   for (const bashId of entries) {
-    const dir = join31(BASHRS_SPILL_ROOT, bashId);
-    const resultPath = join31(dir, "result.json");
+    const dir = join32(BASHRS_SPILL_ROOT, bashId);
+    const resultPath = join32(dir, "result.json");
     const marker = injectedMarker(dir);
     try {
       const markerStat = statSync12(marker);
@@ -21794,8 +21943,8 @@ function prepareDeliveryAck(messageId, claimTimeoutMs, deliveryTimeoutMs) {
   let finishPromise = () => {};
   let timer;
   let unsubscribe = () => {};
-  const promise = new Promise((resolve16) => {
-    finishPromise = resolve16;
+  const promise = new Promise((resolve17) => {
+    finishPromise = resolve17;
   });
   unsubscribe = runtimeBus().subscribe((event) => {
     if (event.type !== "ai-status")
@@ -21864,7 +22013,7 @@ function renderTurnFooter(msg) {
 
 // ../../packages/core/src/outbox/file-ops.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { appendFileSync as appendFileSync2, existsSync as existsSync22, readFileSync as readFileSync19, renameSync as renameSync10, unlinkSync as unlinkSync17 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync23, readFileSync as readFileSync19, renameSync as renameSync10, unlinkSync as unlinkSync17 } from "fs";
 function host() {
   return hostContext.getStore() ?? defaultHost2;
 }
@@ -21881,8 +22030,8 @@ function tryUnlink(path, label, reason) {
 }
 function drainOutboxFile(filePath, label) {
   const processingPath = filePath + PROCESSING_SUFFIX;
-  const hasPending = existsSync22(filePath);
-  const hasLeftover = existsSync22(processingPath);
+  const hasPending = existsSync23(filePath);
+  const hasLeftover = existsSync23(processingPath);
   if (hasLeftover) {
     const logMsg = `${label}: merging leftover .processing before claim`;
     const logCtx = { filePath, processingPath, hadPending: hasPending };
@@ -21902,7 +22051,7 @@ function drainOutboxFile(filePath, label) {
       tryUnlink(processingPath, label, "failed to clean up leftover after merge error");
     }
   }
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
     renameSync10(filePath, processingPath);
@@ -21956,7 +22105,7 @@ var init_file_ops = __esm(() => {
 // ../../packages/core/src/runtime/inbox.ts
 import { createHash as createHash9, randomUUID as randomUUID20 } from "crypto";
 import { readdirSync as readdirSync8, statSync as statSync13, writeFileSync as writeFileSync17 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 async function createAskForkPlan(options) {
   const snapshot = structuredClone(options.entries);
   const prepareSession = async () => options.synthesize(structuredClone(snapshot));
@@ -22096,7 +22245,7 @@ async function flushSessionInbox() {
     return;
   }
   for (const uid of userDirs) {
-    const userInboxDir = join32(SESSION_INBOX_DIR, uid);
+    const userInboxDir = join33(SESSION_INBOX_DIR, uid);
     let entries;
     try {
       entries = readdirSync8(userInboxDir);
@@ -22104,7 +22253,7 @@ async function flushSessionInbox() {
       continue;
     }
     for (const entry of entries) {
-      const entryPath = join32(userInboxDir, entry);
+      const entryPath = join33(userInboxDir, entry);
       let isDir = false;
       try {
         isDir = statSync13(entryPath).isDirectory();
@@ -22194,7 +22343,7 @@ function sweepScheduledSessionInbox(nowMs = Date.now()) {
     return;
   }
   for (const userId of userDirs) {
-    const userInboxDir = join32(SESSION_INBOX_DIR, userId);
+    const userInboxDir = join33(SESSION_INBOX_DIR, userId);
     let files;
     try {
       files = readdirSync8(userInboxDir);
@@ -22206,7 +22355,7 @@ function sweepScheduledSessionInbox(nowMs = Date.now()) {
       const topicId = topicIdFromScheduledSessionInboxFileName(file);
       if (!topicId)
         continue;
-      const schedulePath = join32(userInboxDir, file);
+      const schedulePath = join33(userInboxDir, file);
       const hasProcessingClaim = files.includes(`${file}.processing`);
       if (!hasProcessingClaim && !scheduledFileNeedsClaim(schedulePath, nowMs))
         continue;
@@ -23042,8 +23191,8 @@ var init_src = __esm(async () => {
 });
 
 // ../../packages/core/src/storage/conversation-migration.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync23, mkdirSync as mkdirSync23, readFileSync as readFileSync20 } from "fs";
-import { dirname as dirname15, join as join33 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync24, mkdirSync as mkdirSync23, readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname16, join as join34 } from "path";
 function readEntries(path) {
   const entries = [];
   for (const [index, line] of readFileSync20(path, "utf8").split(`
@@ -23106,20 +23255,20 @@ function migrateLegacyCompactedConversations() {
       const userId = participant.userId;
       const rawPath = getConversationPath(userId, topic.title);
       const activePath = getActiveConversationPath(userId, topic.title);
-      if (!existsSync23(rawPath) || existsSync23(activePath)) {
+      if (!existsSync24(rawPath) || existsSync24(activePath)) {
         result.skipped++;
         continue;
       }
-      const backupPath = join33(resolveStorageDataDir(), "conversation-migration-backups", MIGRATION_NAME, userId, `${sanitizeTopicName(topic.title, true)}.jsonl`);
-      const sourcePath = existsSync23(backupPath) ? backupPath : rawPath;
+      const backupPath = join34(resolveStorageDataDir(), "conversation-migration-backups", MIGRATION_NAME, userId, `${sanitizeTopicName(topic.title, true)}.jsonl`);
+      const sourcePath = existsSync24(backupPath) ? backupPath : rawPath;
       const legacyEntries = readEntries(sourcePath);
       const compactIndex = compactionEntryIndex(legacyEntries);
       if (compactIndex < 0) {
         result.skipped++;
         continue;
       }
-      if (!existsSync23(backupPath)) {
-        mkdirSync23(dirname15(backupPath), { recursive: true });
+      if (!existsSync24(backupPath)) {
+        mkdirSync23(dirname16(backupPath), { recursive: true });
         copyFileSync3(rawPath, backupPath);
       }
       const compactedAt = legacyEntries[compactIndex]?.ts;
@@ -23169,8 +23318,8 @@ __export(exports_decisions, {
   createDecisions: () => createDecisions,
   DECISION_STATUS_VALUES: () => DECISION_STATUS_VALUES
 });
-import { existsSync as existsSync24, mkdirSync as mkdirSync24, readFileSync as readFileSync21, renameSync as renameSync11, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname16, join as join34 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync24, readFileSync as readFileSync21, renameSync as renameSync11, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname17, join as join35 } from "path";
 function safeDecisionScopeKey(scopeKey) {
   const safe = sanitizeFileName(scopeKey);
   if (!safe || safe === "." || safe === "..") {
@@ -23182,14 +23331,14 @@ function decisionScopeKey(opts) {
   return opts.topicId?.trim() || opts.session || "default";
 }
 function getDecisionFilePath(userId, scopeKey) {
-  return join34(resolveStorageDataDir(), "decisions", `${safeDecisionScopeKey(scopeKey)}.json`);
+  return join35(resolveStorageDataDir(), "decisions", `${safeDecisionScopeKey(scopeKey)}.json`);
 }
 function getDecisionGraphSvgPath(userId, scopeKey) {
-  return join34(resolveStorageDataDir(), "decision-renders", safeDecisionScopeKey(scopeKey), "latest.svg");
+  return join35(resolveStorageDataDir(), "decision-renders", safeDecisionScopeKey(scopeKey), "latest.svg");
 }
 function writeDecisionGraphSvg(userId, scopeKey, svg) {
   const path = getDecisionGraphSvgPath(userId, scopeKey);
-  mkdirSync24(dirname16(path), { recursive: true });
+  mkdirSync24(dirname17(path), { recursive: true });
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync18(tmp, svg, "utf-8");
   renameSync11(tmp, path);
@@ -23197,7 +23346,7 @@ function writeDecisionGraphSvg(userId, scopeKey, svg) {
 }
 function readDecisions(userId, scopeKey) {
   const path = getDecisionFilePath(userId, scopeKey);
-  if (!existsSync24(path))
+  if (!existsSync25(path))
     return [];
   try {
     const parsed = JSON.parse(readFileSync21(path, "utf-8"));
@@ -23209,7 +23358,7 @@ function readDecisions(userId, scopeKey) {
 }
 function writeDecisions(userId, scopeKey, decisions) {
   const path = getDecisionFilePath(userId, scopeKey);
-  mkdirSync24(dirname16(path), { recursive: true });
+  mkdirSync24(dirname17(path), { recursive: true });
   const payload = { version: 1, decisions };
   const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync18(tmp, JSON.stringify(payload, null, 2), "utf-8");
@@ -23468,8 +23617,8 @@ var init_node_host = __esm(async () => {
 });
 
 // ../../packages/core/src/agents/mcp-tools/inline-assets.ts
-import { existsSync as existsSync25, readFileSync as readFileSync22, statSync as statSync14 } from "fs";
-import { extname as extname2, isAbsolute as isAbsolute6, resolve as resolve16 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync22, statSync as statSync14 } from "fs";
+import { extname as extname2, isAbsolute as isAbsolute6, resolve as resolve17 } from "path";
 function isNonLocal(ref) {
   return /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(ref.trim());
 }
@@ -23493,10 +23642,10 @@ function inlineLocalAssets(html, options) {
     const relPath = stripSuffix(ref);
     if (!relPath)
       return null;
-    const abs = isAbsolute6(relPath) ? relPath : resolve16(baseDir, relPath);
+    const abs = isAbsolute6(relPath) ? relPath : resolve17(baseDir, relPath);
     let bytes;
     try {
-      if (!existsSync25(abs) || !statSync14(abs).isFile()) {
+      if (!existsSync26(abs) || !statSync14(abs).isFile()) {
         unresolved.push(ref);
         cache.set(ref, null);
         return null;
@@ -24444,8 +24593,8 @@ __export(exports_agent_health, {
   createAgentHealthMcpServer: () => createAgentHealthMcpServer
 });
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync26, readdirSync as readdirSync9 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync9 } from "fs";
+import { join as join36 } from "path";
 import { McpServer as McpServer5 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z10 } from "zod";
 function signalProcessTree2(child, signal) {
@@ -24461,7 +24610,7 @@ function signalProcessTree2(child, signal) {
   }
 }
 function spawnCapture(cmd, args, timeoutMs, signal, env) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     const child = spawn6(cmd, args, {
       env: env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -24519,7 +24668,7 @@ function spawnCapture(cmd, args, timeoutMs, signal, env) {
       if (killTimer)
         clearTimeout(killTimer);
       if (code === 0)
-        resolve17({ stdout, stderr });
+        resolve18({ stdout, stderr });
       else
         reject(new Error(stderr.trim() || `${cmd} exited with ${code ?? exitSignal}`));
     });
@@ -24597,11 +24746,11 @@ async function checkMaestro(model, timeoutMs, signal) {
       const remaining = deadline - Date.now();
       if (remaining <= 0)
         throw new Error("timeout");
-      const eventResult = await new Promise((resolve17, reject) => {
+      const eventResult = await new Promise((resolve18, reject) => {
         const timeout = setTimeout(() => reject(new Error("timeout")), remaining);
         const onAbort = () => reject(new Error("aborted"));
         signal.addEventListener("abort", onAbort, { once: true });
-        activeIterator.next().then(resolve17, reject).finally(() => {
+        activeIterator.next().then(resolve18, reject).finally(() => {
           clearTimeout(timeout);
           signal.removeEventListener("abort", onAbort);
         });
@@ -24631,7 +24780,7 @@ function getDefaultModel(registry) {
 }
 async function withCheckSlot(operation) {
   if (activeChecks >= MAX_CONCURRENT_CHECKS) {
-    await new Promise((resolve17) => checkWaiters.push(resolve17));
+    await new Promise((resolve18) => checkWaiters.push(resolve18));
   }
   activeChecks += 1;
   try {
@@ -24689,8 +24838,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 = join35(USERS_LOG_DIR, context.userId, "active-queries");
-    if (!existsSync26(stateDir))
+    const stateDir = join36(USERS_LOG_DIR, context.userId, "active-queries");
+    if (!existsSync27(stateDir))
       return mcpOk("\uC2E4\uD589 \uC911\uC778 \uCFFC\uB9AC \uC5C6\uC74C");
     let files;
     try {
@@ -24702,7 +24851,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(join35(stateDir, file));
+      const state = readJsonFile(join36(stateDir, file));
       if (!state)
         return [];
       const sinceMs = new Date(state.since).getTime();
@@ -24935,7 +25084,7 @@ var exports_default_host = {};
 __export(exports_default_host, {
   createDefaultSessionCommMcpHost: () => createDefaultSessionCommMcpHost
 });
-import { basename as basename6, join as join36 } from "path";
+import { basename as basename6, join as join37 } from "path";
 function ok2(text2) {
   return { content: [{ type: "text", text: text2 }] };
 }
@@ -24982,10 +25131,10 @@ function remoteTarget(context, to) {
   return { node: to.slice(0, slash), topic: to.slice(slash + 1) };
 }
 function activeQuery(context, topicId, title) {
-  const dir = join36(USERS_LOG_DIR, context.userId, "active-queries");
-  const candidates = [join36(dir, `${sanitizeId(topicId)}.json`)];
+  const dir = join37(USERS_LOG_DIR, context.userId, "active-queries");
+  const candidates = [join37(dir, `${sanitizeId(topicId)}.json`)];
   if (title && basename6(title) === title && title !== "." && title !== "..") {
-    candidates.push(join36(dir, `${title}.json`));
+    candidates.push(join37(dir, `${title}.json`));
   }
   for (const path of candidates) {
     const state = readJsonFile(path);
@@ -25276,298 +25425,15 @@ var init_default_host = __esm(async () => {
   init_types();
 });
 
-// ../../packages/core/src/mcp/vault-http.ts
-function substituteObject(userId, values, host2) {
-  const used = new Set;
-  const substituted = {};
-  for (const [key, value] of Object.entries(values)) {
-    if (FORBIDDEN_REQUEST_HEADERS.has(key.toLowerCase())) {
-      throw new Error(`Header "${key}" is not allowed`);
-    }
-    const result = host2.substitute(userId, value);
-    for (const usedKey of result.usedKeys)
-      used.add(usedKey);
-    substituted[key] = result.text;
-  }
-  return { values: substituted, usedKeys: [...used] };
-}
-function safeResponseHeaders(userId, headers, host2) {
-  const output = {};
-  for (const [key, value] of headers.entries()) {
-    if (!SAFE_RESPONSE_HEADERS.has(key.toLowerCase()))
-      continue;
-    output[key] = host2.redact(userId, value);
-  }
-  return output;
-}
-async function readBoundedBody(response, maxBytes) {
-  if (!response.body)
-    return { bytes: new Uint8Array, truncated: false };
-  const reader = response.body.getReader();
-  const chunks = [];
-  let keptBytes = 0;
-  let truncated = false;
-  try {
-    while (true) {
-      const next = await reader.read();
-      if (next.done)
-        break;
-      const remaining = maxBytes - keptBytes;
-      if (remaining <= 0) {
-        truncated = true;
-        await reader.cancel();
-        break;
-      }
-      const visible = next.value.subarray(0, remaining);
-      chunks.push(visible);
-      keptBytes += visible.byteLength;
-      if (visible.byteLength < next.value.byteLength) {
-        truncated = true;
-        await reader.cancel();
-        break;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const bytes = new Uint8Array(keptBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return { bytes, truncated };
-}
-async function executeVaultHttpRequest(userId, request, host2, fetchImpl = fetch) {
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(request.url);
-  } catch {
-    return { ok: false, error: "url must be an absolute HTTPS URL" };
-  }
-  if (parsedUrl.protocol !== "https:") {
-    return {
-      ok: false,
-      error: "Vault credentials may only be sent over HTTPS"
-    };
-  }
-  if (parsedUrl.username || parsedUrl.password || /\{\{[^}]+\}\}/.test(request.url)) {
-    return {
-      ok: false,
-      error: "Keep Vault placeholders out of URLs; put credentials in headers or body"
-    };
-  }
-  let headers;
-  let headerKeys;
-  try {
-    const substituted = substituteObject(userId, request.headers ?? {}, host2);
-    headers = substituted.values;
-    headerKeys = substituted.usedKeys;
-  } catch (error2) {
-    return {
-      ok: false,
-      error: error2 instanceof Error ? error2.message : String(error2)
-    };
-  }
-  const bodyResult = request.body === undefined ? { text: undefined, usedKeys: [] } : host2.substitute(userId, request.body);
-  const usedKeys = [...new Set([...headerKeys, ...bodyResult.usedKeys])].sort();
-  if (usedKeys.length === 0) {
-    return {
-      ok: false,
-      error: "No valid Vault placeholder was found in headers or body"
-    };
-  }
-  if (request.method === "GET" && request.body !== undefined) {
-    return {
-      ok: false,
-      error: "GET requests cannot include a credential-bearing body"
-    };
-  }
-  const controller = new AbortController;
-  const timeoutMs = Math.min(Math.max(request.timeoutMs ?? 30000, 1000), 120000);
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  const startedAt = Date.now();
-  try {
-    const response = await fetchImpl(parsedUrl, {
-      method: request.method,
-      headers,
-      body: request.method === "GET" ? undefined : bodyResult.text,
-      redirect: "manual",
-      signal: controller.signal
-    });
-    const maxBytes = Math.min(Math.max(request.maxResponseBytes ?? 256 * 1024, 1024), 1024 * 1024);
-    const { bytes, truncated } = await readBoundedBody(response, maxBytes);
-    const contentType = response.headers.get("content-type")?.toLowerCase() ?? "";
-    const textual = contentType.startsWith("text/") || contentType.includes("json") || contentType.includes("xml") || contentType.includes("javascript") || contentType === "";
-    const body = textual ? host2.redact(userId, new TextDecoder().decode(bytes)) : `[binary response omitted: ${bytes.byteLength} bytes, ${contentType || "unknown content type"}]`;
-    host2.log?.("info", {
-      userId,
-      vaultKeys: usedKeys,
-      host: parsedUrl.hostname,
-      method: request.method,
-      status: response.status,
-      durationMs: Date.now() - startedAt
-    }, "vault credential used");
-    return {
-      ok: response.ok,
-      status: response.status,
-      statusText: response.statusText,
-      headers: safeResponseHeaders(userId, response.headers, host2),
-      body,
-      truncated
-    };
-  } catch (error2) {
-    const raw = error2 instanceof Error ? error2.message : String(error2);
-    host2.log?.("warn", {
-      userId,
-      vaultKeys: usedKeys,
-      host: parsedUrl.hostname,
-      method: request.method,
-      durationMs: Date.now() - startedAt
-    }, "vault credential request failed");
-    return { ok: false, error: host2.redact(userId, raw) };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-var SAFE_RESPONSE_HEADERS, FORBIDDEN_REQUEST_HEADERS;
-var init_vault_http = __esm(() => {
-  SAFE_RESPONSE_HEADERS = new Set([
-    "content-type",
-    "content-length",
-    "location",
-    "retry-after",
-    "x-ratelimit-limit",
-    "x-ratelimit-remaining",
-    "x-ratelimit-reset"
-  ]);
-  FORBIDDEN_REQUEST_HEADERS = new Set([
-    "connection",
-    "content-length",
-    "host",
-    "proxy-authorization",
-    "transfer-encoding"
-  ]);
-});
-
-// ../../packages/core/src/mcp/vault-run.ts
-import { spawn as spawn7 } from "child_process";
-function appendBounded(chunks, chunk, state, maxBytes) {
-  if (state.bytes >= maxBytes) {
-    state.truncated = true;
-    return;
-  }
-  const remaining = maxBytes - state.bytes;
-  const visible = chunk.subarray(0, remaining);
-  chunks.push(visible);
-  state.bytes += visible.byteLength;
-  if (visible.byteLength < chunk.byteLength)
-    state.truncated = true;
-}
-async function executeVaultRun(userId, request, host2) {
-  const substitution = host2.substitute(userId, request.command);
-  if (substitution.usedKeys.length === 0) {
-    return {
-      ok: false,
-      exitCode: null,
-      signal: null,
-      stdout: "",
-      stderr: "",
-      truncated: false,
-      usedKeys: [],
-      error: "No valid Vault placeholder was found in command"
-    };
-  }
-  const timeoutMs = Math.min(Math.max(request.timeoutMs ?? 120000, 1000), 600000);
-  const maxOutputBytes = Math.min(Math.max(request.maxOutputBytes ?? 512 * 1024, 1024), 2 * 1024 * 1024);
-  const stdoutChunks = [];
-  const stderrChunks = [];
-  const stdoutState = { bytes: 0, truncated: false };
-  const stderrState = { bytes: 0, truncated: false };
-  const startedAt = Date.now();
-  return await new Promise((resolve17) => {
-    const child = spawn7(process.env.SHELL || "/bin/sh", ["-s"], {
-      cwd: request.cwd,
-      detached: true,
-      env: process.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let settled = false;
-    let timedOut = false;
-    const signalTree = (signal) => {
-      if (!child.pid)
-        return;
-      try {
-        process.kill(-child.pid, signal);
-      } catch {
-        try {
-          child.kill(signal);
-        } catch {}
-      }
-    };
-    const finish = (result) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timeout);
-      host2.log?.("info", {
-        userId,
-        vaultKeys: substitution.usedKeys,
-        exitCode: result.exitCode,
-        signal: result.signal,
-        durationMs: Date.now() - startedAt,
-        timedOut
-      }, "vault credential command used");
-      resolve17({ ...result, usedKeys: substitution.usedKeys });
-    };
-    child.stdout.on("data", (chunk) => appendBounded(stdoutChunks, chunk, stdoutState, maxOutputBytes));
-    child.stderr.on("data", (chunk) => appendBounded(stderrChunks, chunk, stderrState, maxOutputBytes));
-    child.once("error", (error2) => {
-      finish({
-        ok: false,
-        exitCode: null,
-        signal: null,
-        stdout: "",
-        stderr: "",
-        truncated: false,
-        error: host2.redact(userId, error2.message)
-      });
-    });
-    child.once("close", (exitCode, signal) => {
-      signalTree("SIGTERM");
-      const stdout = host2.redact(userId, Buffer.concat(stdoutChunks).toString("utf8"));
-      const stderr = host2.redact(userId, Buffer.concat(stderrChunks).toString("utf8"));
-      finish({
-        ok: !timedOut && exitCode === 0,
-        exitCode,
-        signal,
-        stdout,
-        stderr,
-        truncated: stdoutState.truncated || stderrState.truncated,
-        ...timedOut ? { error: `Command timed out after ${timeoutMs}ms` } : {}
-      });
-    });
-    const timeout = setTimeout(() => {
-      timedOut = true;
-      signalTree("SIGKILL");
-    }, timeoutMs);
-    child.stdin.end(substitution.text);
-  });
-}
-var init_vault_run = () => {};
-
 // ../../packages/core/src/mcp/factories/vault.ts
 var exports_vault = {};
 __export(exports_vault, {
   createVaultMcpServer: () => createVaultMcpServer
 });
 import { McpServer as McpServer7 } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z12 } from "zod";
-function createVaultMcpServer(context, host2, executors = {}) {
+function createVaultMcpServer(context, host2) {
   const server = new McpServer7({ name: "vault", version: "1.0.0" });
-  const run = executors.run ?? executeVaultRun;
-  const http = executors.http ?? executeVaultHttpRequest;
-  server.tool("vault_list", context.httpOnly ? "List the user's Vault keys and descriptions without exposing values. Use vault_http_request for HTTPS APIs that need a credential." : "List the user's Vault keys and descriptions without exposing values. Use vault_http_request for APIs and vault_run for shell/CLI work that needs a credential.", {}, () => {
+  server.tool("vault_list", "List the user's Vault keys and descriptions without exposing values. Use {{KEY}} placeholders directly in supported transient tool inputs.", {}, () => {
     if (!context.userId)
       return mcpOk("(vault unavailable: no user context)");
     const entries = host2.list(context.userId);
@@ -25578,54 +25444,14 @@ function createVaultMcpServer(context, host2, executors = {}) {
 ${lines.join(`
 `)}`);
   });
-  if (!context.listOnly && !context.httpOnly) {
-    server.tool("vault_run", "Run a shell command containing {{KEY}} references inside Otium's credential broker. Expanded command input never reaches the model/provider, and stdout/stderr are redacted before return. Prefer vault_http_request for HTTP APIs.", {
-      command: z12.string().min(1).max(64 * 1024),
-      timeout_ms: z12.number().int().min(1000).max(600000).optional(),
-      max_output_bytes: z12.number().int().min(1024).max(2 * 1024 * 1024).optional()
-    }, async ({ command, timeout_ms, max_output_bytes }) => {
-      if (!context.userId)
-        return mcpError("Vault unavailable: no user context");
-      const result = await run(context.userId, {
-        command,
-        timeoutMs: timeout_ms,
-        maxOutputBytes: max_output_bytes,
-        cwd: context.cwd
-      }, host2);
-      return result.error && result.exitCode === null ? mcpError(result.error) : mcpOk(JSON.stringify(result, null, 2));
-    });
-  }
-  if (!context.listOnly)
-    server.tool("vault_http_request", "Make an HTTPS request with {{KEY}} references resolved inside Otium. Put secrets in headers or body, never in the URL. The expanded request is not returned; the response is redacted before the model sees it.", {
-      method: z12.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).default("GET"),
-      url: z12.string().url().describe("Absolute HTTPS URL without Vault placeholders"),
-      headers: z12.record(z12.string(), z12.string()).optional(),
-      body: z12.string().optional(),
-      timeout_ms: z12.number().int().min(1000).max(120000).optional(),
-      max_response_bytes: z12.number().int().min(1024).max(1024 * 1024).optional()
-    }, async ({ method, url, headers, body, timeout_ms, max_response_bytes }) => {
-      if (!context.userId)
-        return mcpError("Vault unavailable: no user context");
-      const result = await http(context.userId, {
-        method,
-        url,
-        headers,
-        body,
-        timeoutMs: timeout_ms,
-        maxResponseBytes: max_response_bytes
-      }, host2);
-      return result.error ? mcpError(result.error) : mcpOk(JSON.stringify(result, null, 2));
-    });
   return server;
 }
 var init_vault2 = __esm(() => {
-  init_vault_http();
-  init_vault_run();
   init_mcp_helpers();
 });
 
 // ../../packages/core/src/mcp/wiki-search-index.ts
-import { chmodSync as chmodSync5, existsSync as existsSync27, readFileSync as readFileSync23, unlinkSync as unlinkSync18 } from "fs";
+import { chmodSync as chmodSync5, existsSync as existsSync28, readFileSync as readFileSync23, unlinkSync as unlinkSync18 } from "fs";
 function documentId(source) {
   return `${source.kind}:${source.key}`;
 }
@@ -25827,7 +25653,7 @@ class WikiSearchIndex {
 }
 function resetCorruptWikiSearchIndex(path) {
   for (const candidate of [path, `${path}-journal`, `${path}-wal`, `${path}-shm`]) {
-    if (!existsSync27(candidate))
+    if (!existsSync28(candidate))
       continue;
     unlinkSync18(candidate);
   }
@@ -25847,7 +25673,7 @@ import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { randomUUID as randomUUID21 } from "crypto";
 import {
   closeSync as closeSync4,
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync25,
   openSync as openSync4,
   readdirSync as readdirSync10,
@@ -25857,7 +25683,7 @@ import {
   unlinkSync as unlinkSync19,
   writeFileSync as writeFileSync19
 } from "fs";
-import { basename as basename7, dirname as dirname17, join as join37, relative as relative2, resolve as resolve17 } from "path";
+import { basename as basename7, dirname as dirname18, join as join38, relative as relative2, resolve as resolve18 } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport as StdioServerTransport2 } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -26092,7 +25918,7 @@ function trigramSimilarity(left, right) {
   return 2 * overlap / (a.size + b.size);
 }
 function openWikiSearchIndex() {
-  const path = resolve17(runtime().wikiDir, WIKI_SEARCH_INDEX_FILENAME);
+  const path = resolve18(runtime().wikiDir, WIKI_SEARCH_INDEX_FILENAME);
   try {
     return new WikiSearchIndex(path);
   } catch (error2) {
@@ -26119,7 +25945,7 @@ function prepareWikiSearchDocument(kind, key, text2) {
 }
 function indexWikiSearchDocument(kind, key, text2) {
   const root = kind === "article" ? runtime().articlesDir : runtime().summariesDir;
-  const path = resolve17(root, `${key}.md`);
+  const path = resolve18(root, `${key}.md`);
   const index = openWikiSearchIndex();
   if (!index)
     return false;
@@ -26134,7 +25960,7 @@ function indexWikiSearchDocument(kind, key, text2) {
   }
 }
 function wikiIndexPath(kind) {
-  return resolve17(runtime().wikiDir, WIKI_INDEX_FILENAMES[kind]);
+  return resolve18(runtime().wikiDir, WIKI_INDEX_FILENAMES[kind]);
 }
 function normalizeIndexDescription(raw) {
   const description = raw.replaceAll(/\s+/g, " ").trim();
@@ -26190,7 +26016,7 @@ function indexCandidateExists(candidate) {
   if (candidate.kind === "topic")
     return true;
   const root = candidate.kind === "article" ? runtime().articlesDir : runtime().summariesDir;
-  const filePath = resolve17(root, `${candidate.key}.md`);
+  const filePath = resolve18(root, `${candidate.key}.md`);
   const relativePath = relative2(root, filePath);
   if (relativePath.startsWith("..") || relativePath.startsWith("/"))
     return false;
@@ -26272,8 +26098,8 @@ function wikiQuery(args) {
   const canReadTopicMemory = runtime().host.canReadTopicMemory;
   const temporalDirection = /\b(?:latest|newest|recent)\b|\uCD5C\uADFC|\uCD5C\uC2E0/.test(normalizedQuery) ? "newest" : /\b(?:earliest|oldest)\b|\uAC00\uC7A5 \uC624\uB798\uB41C|\uCD5C\uCD08/.test(normalizedQuery) ? "oldest" : undefined;
   const visibleIndexCandidates = [
-    ...parseWikiIndex(resolve17(runtime().wikiDir, "topic-index.md")),
-    ...parseWikiIndex(resolve17(runtime().wikiDir, "article-index.md"))
+    ...parseWikiIndex(resolve18(runtime().wikiDir, "topic-index.md")),
+    ...parseWikiIndex(resolve18(runtime().wikiDir, "article-index.md"))
   ].filter((candidate) => kind === "all" || candidate.kind === kind).filter((candidate) => candidate.kind !== "topic" || !canReadTopicMemory || canReadTopicMemory(candidate.key, runtime().userId));
   const hasStaleExactIndexMatch = visibleIndexCandidates.some((candidate) => !indexCandidateExists(candidate) && scoreIndexKey(question, candidate.key) >= 100);
   const indexCandidates = visibleIndexCandidates.filter(indexCandidateExists).map((candidate) => ({
@@ -26307,13 +26133,13 @@ function wikiQuery(args) {
     try {
       for (const entry of readdirSync10(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          const sub = join37(dir, entry.name);
+          const sub = join38(dir, entry.name);
           if (label === "articles" || label === "skills") {
             try {
               for (const f of readdirSync10(sub, { withFileTypes: true })) {
                 if (!f.isFile() || !f.name.endsWith(".md"))
                   continue;
-                const fp = join37(sub, f.name);
+                const fp = join38(sub, f.name);
                 try {
                   const text2 = readFileSync24(fp, "utf-8");
                   const key = `${entry.name}/${f.name.replace(/\.md$/i, "")}`;
@@ -26334,7 +26160,7 @@ function wikiQuery(args) {
           if (label === "topic" && canReadTopicMemory && !canReadTopicMemory(entry.name.replace(/\.md$/i, ""), runtime().userId)) {
             continue;
           }
-          const fp = join37(dir, entry.name);
+          const fp = join38(dir, entry.name);
           try {
             const text2 = readFileSync24(fp, "utf-8");
             const key = entry.name.replace(/\.md$/i, "");
@@ -26618,7 +26444,7 @@ function wikiTopicBrief(args) {
     };
   }
   const topicKey = wikiSummarySlug(rawTopic.replace(/^topic\//, "").replace(/\.md$/i, ""));
-  const filePath = resolve17(runtime().topicsDir, `${topicKey}.md`);
+  const filePath = resolve18(runtime().topicsDir, `${topicKey}.md`);
   try {
     const content = readFileSync24(filePath, "utf-8");
     return {
@@ -26666,7 +26492,7 @@ Adopted topic memory: ${memoryKey}` }]
   }
   const root = kind === "summary" ? runtime().summariesDir : runtime().articlesDir;
   const key = rawKey.replace(new RegExp(`^(?:${kind === "summary" ? "summaries" : "articles"})/`), "").replace(/\.md$/i, "");
-  const filePath = resolve17(root, `${key}.md`);
+  const filePath = resolve18(root, `${key}.md`);
   const relativePath = relative2(root, filePath);
   if (relativePath.startsWith("..") || relativePath.startsWith("/")) {
     return { content: [{ type: "text", text: "Invalid wiki document key." }], isError: true };
@@ -26690,18 +26516,18 @@ function wikiLastConversation(args) {
     return { content: [{ type: "text", text: "No topic specified." }] };
   }
   const name = slugify(topicNameFrom(rawTopic));
-  const archiveDir = resolve17(runtime().archiveDir, name);
+  const archiveDir = resolve18(runtime().archiveDir, name);
   try {
-    let files = existsSync28(archiveDir) ? readdirSync10(archiveDir).filter((f) => f.endsWith(".jsonl")).sort().reverse() : [];
+    let files = existsSync29(archiveDir) ? readdirSync10(archiveDir).filter((f) => f.endsWith(".jsonl")).sort().reverse() : [];
     if (files.length === 0) {
-      files = existsSync28(runtime().archiveDir) ? readdirSync10(runtime().archiveDir).filter((f) => f.startsWith(name) && f.endsWith(".jsonl")).sort().reverse() : [];
+      files = existsSync29(runtime().archiveDir) ? readdirSync10(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] : resolve17(existsSync28(archiveDir) && readdirSync10(archiveDir).includes(files[0]) ? archiveDir : runtime().archiveDir, files[0]);
+    const actualPath = files[0].includes("/") ? files[0] : resolve18(existsSync29(archiveDir) && readdirSync10(archiveDir).includes(files[0]) ? archiveDir : runtime().archiveDir, files[0]);
     try {
       const raw = readFileSync24(actualPath, "utf-8");
       const lines = raw.trim().split(`
@@ -26774,7 +26600,7 @@ function skillQuery(args) {
     })) {
       if (!entry.isDirectory())
         continue;
-      const skillFile = resolve17(runtime().skillsDir, entry.name, "skill.md");
+      const skillFile = resolve18(runtime().skillsDir, entry.name, "skill.md");
       try {
         const text2 = readFileSync24(skillFile, "utf-8");
         const lower = text2.toLowerCase();
@@ -26842,9 +26668,9 @@ ${fresh.join(`
 `)}
 `;
   }
-  const skillDir = resolve17(runtime().skillsDir, name);
+  const skillDir = resolve18(runtime().skillsDir, name);
   ensureDir(skillDir);
-  const skillPath = resolve17(skillDir, "skill.md");
+  const skillPath = resolve18(skillDir, "skill.md");
   let finalContent = content;
   try {
     const existing = readFileSync24(skillPath, "utf-8");
@@ -26869,7 +26695,7 @@ function writeSummaryDocument(rawTopic, content, dateStr) {
   let counter = 1;
   while (true) {
     try {
-      writeFileSync19(resolve17(runtime().summariesDir, summaryName), content, {
+      writeFileSync19(resolve18(runtime().summariesDir, summaryName), content, {
         encoding: "utf-8",
         flag: "wx"
       });
@@ -26886,8 +26712,8 @@ function writeSummaryDocument(rawTopic, content, dateStr) {
   let sqliteUpdated = false;
   if (topicId && setTopicBrief2) {
     try {
-      const briefPath = resolve17(runtime().topicsDir, `${fileSlug}.md`);
-      let briefMd = existsSync28(briefPath) ? readFileSync24(briefPath, "utf-8") : undefined;
+      const briefPath = resolve18(runtime().topicsDir, `${fileSlug}.md`);
+      let briefMd = existsSync29(briefPath) ? readFileSync24(briefPath, "utf-8") : undefined;
       if (briefMd === undefined && getTopicBrief2 && !getTopicBrief2(fileSlug)?.briefMd) {
         const legacy = getTopicBrief2(topicId)?.briefMd;
         if (legacy)
@@ -26906,9 +26732,9 @@ function writeSummaryDocument(rawTopic, content, dateStr) {
 function writeTopicDocument(rawTopic, content) {
   const topicId = runtime().topicId;
   const fileSlug = wikiBriefStorageKey(rawTopic, topicId);
-  const briefPath = resolve17(runtime().topicsDir, `${fileSlug}.md`);
-  ensureDir(dirname17(briefPath));
-  const existed = existsSync28(briefPath);
+  const briefPath = resolve18(runtime().topicsDir, `${fileSlug}.md`);
+  ensureDir(dirname18(briefPath));
+  const existed = existsSync29(briefPath);
   writeFileSync19(briefPath, content, "utf-8");
   const setTopicBrief2 = runtime().host.setTopicBrief;
   let sqliteUpdated = false;
@@ -26921,9 +26747,9 @@ function writeTopicDocument(rawTopic, content) {
   return { slug: fileSlug, existed, sqliteUpdated };
 }
 function writeArticleDocument(slug, content) {
-  const articlePath = resolve17(runtime().articlesDir, `${slug}.md`);
-  ensureDir(dirname17(articlePath));
-  const existed = existsSync28(articlePath);
+  const articlePath = resolve18(runtime().articlesDir, `${slug}.md`);
+  ensureDir(dirname18(articlePath));
+  const existed = existsSync29(articlePath);
   atomicWriteFile(articlePath, content);
   return { existed };
 }
@@ -27055,21 +26881,21 @@ function collectIndexableDocuments() {
     }
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".md")) {
-        add(kind, entry.name.replace(/\.md$/i, ""), join37(root, entry.name));
+        add(kind, entry.name.replace(/\.md$/i, ""), join38(root, entry.name));
         continue;
       }
       if (!entry.isDirectory() || !allowSubdirectories)
         continue;
       let nested;
       try {
-        nested = readdirSync10(join37(root, entry.name), { withFileTypes: true });
+        nested = readdirSync10(join38(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, "")}`, join37(root, entry.name, file.name));
+        add(kind, `${entry.name}/${file.name.replace(/\.md$/i, "")}`, join38(root, entry.name, file.name));
       }
     }
   }
@@ -27126,7 +26952,7 @@ function indexRowOrPartialWrite(label, options) {
 function upsertIndexRow(options) {
   const { kind, slug, description, date, section } = options;
   const indexPath = wikiIndexPath(kind);
-  ensureDir(dirname17(indexPath));
+  ensureDir(dirname18(indexPath));
   const releaseLock = acquireFileLock(indexPath);
   try {
     let index;
@@ -27183,7 +27009,7 @@ function upsertIndexRow(options) {
 }
 function wikiDocumentExists(kind, slug) {
   const root = kind === "article" ? runtime().articlesDir : kind === "summary" ? runtime().summariesDir : kind === "topic" ? runtime().topicsDir : runtime().skillsDir;
-  const filePath = resolve17(root, `${slug}.md`);
+  const filePath = resolve18(root, `${slug}.md`);
   if (relative2(root, filePath).startsWith(".."))
     return false;
   try {
@@ -27235,7 +27061,7 @@ function indexUpsert(args) {
 }
 function createWikiMcpServer(context, host2) {
   const surface = context.surface ?? "all";
-  const wikiDir = resolve17(host2.wikiRoot);
+  const wikiDir = resolve18(host2.wikiRoot);
   const current3 = {
     userId: context.userId,
     currentTopicId: context.currentTopicId ?? context.topicId,
@@ -27243,11 +27069,11 @@ function createWikiMcpServer(context, host2) {
     surface,
     host: host2,
     wikiDir,
-    skillsDir: resolve17(wikiDir, "skills"),
-    topicsDir: resolve17(wikiDir, "topic"),
-    summariesDir: resolve17(wikiDir, "summaries"),
-    articlesDir: resolve17(wikiDir, "articles"),
-    archiveDir: resolve17(wikiDir, "archive")
+    skillsDir: resolve18(wikiDir, "skills"),
+    topicsDir: resolve18(wikiDir, "topic"),
+    summariesDir: resolve18(wikiDir, "summaries"),
+    articlesDir: resolve18(wikiDir, "articles"),
+    archiveDir: resolve18(wikiDir, "archive")
   };
   const tools = surface === "wiki" ? WIKI_TOOLS : surface === "skills" ? SKILL_TOOLS : [...WIKI_TOOLS, ...SKILL_TOOLS];
   for (const directory of [
@@ -27570,7 +27396,7 @@ __export(exports_activity_log, {
   readSentFilesForTopic: () => readSentFilesForTopic
 });
 import {
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   mkdirSync as mkdirSync26,
   readdirSync as readdirSync11,
   renameSync as renameSync13,
@@ -27578,7 +27404,7 @@ import {
   unlinkSync as unlinkSync20,
   writeFileSync as writeFileSync20
 } from "fs";
-import { basename as basename8, join as join38 } from "path";
+import { basename as basename8, join as join39 } from "path";
 function startLogRotation() {
   if (rotationTimer)
     return;
@@ -27592,7 +27418,7 @@ function writeLog(entry) {
   mkdirSync26(logDir, { recursive: true });
   const safeSession = sanitizeTopicName(entry.session);
   const sidShort = entry.sessionId ? entry.sessionId.slice(0, 8) : "new";
-  const file = join38(logDir, `${entry.userId}_${safeSession}_${sidShort}.jsonl`);
+  const file = join39(logDir, `${entry.userId}_${safeSession}_${sidShort}.jsonl`);
   try {
     const stat = statSync16(file);
     if (stat.size >= MAX_FILE_SIZE) {
@@ -27612,7 +27438,7 @@ function rotateOldLogs() {
   try {
     const files = readdirSync11(logDir).filter((f) => f.endsWith(".jsonl")).map((f) => {
       try {
-        const stat = statSync16(join38(logDir, f));
+        const stat = statSync16(join39(logDir, f));
         return { name: f, size: stat.size, mtimeMs: stat.mtimeMs };
       } catch {
         return null;
@@ -27628,7 +27454,7 @@ function rotateOldLogs() {
       if (freed >= toFree)
         break;
       try {
-        unlinkSync20(join38(logDir, file.name));
+        unlinkSync20(join39(logDir, file.name));
         freed += file.size;
         logger.info({ file: file.name, sizeKB: (file.size / 1024).toFixed(0) }, "Rotated out old log");
       } catch (e) {
@@ -27640,9 +27466,9 @@ function rotateOldLogs() {
   }
 }
 function writeSentFileLog(entry) {
-  const dir = join38(resolveStorageUsersLogDir(), String(entry.userId));
+  const dir = join39(resolveStorageUsersLogDir(), String(entry.userId));
   mkdirSync26(dir, { recursive: true });
-  const file = join38(dir, "sent-files.jsonl");
+  const file = join39(dir, "sent-files.jsonl");
   try {
     appendJsonlEntry(file, { ...entry, fileName: basename8(entry.filePath) });
   } catch (e) {
@@ -27653,8 +27479,8 @@ function entryMatchesTopic(e, topicName) {
   return e.topicName === topicName;
 }
 function readSentFilesForTopic(userId, topicName) {
-  const file = join38(resolveStorageUsersLogDir(), String(userId), "sent-files.jsonl");
-  if (!existsSync29(file))
+  const file = join39(resolveStorageUsersLogDir(), String(userId), "sent-files.jsonl");
+  if (!existsSync30(file))
     return [];
   try {
     return readJsonlLines(file).map((line) => JSON.parse(line)).filter((e) => entryMatchesTopic(e, topicName));
@@ -27664,8 +27490,8 @@ function readSentFilesForTopic(userId, topicName) {
   }
 }
 function removeSentFilesForTopic(userId, topicName) {
-  const file = join38(resolveStorageUsersLogDir(), String(userId), "sent-files.jsonl");
-  if (!existsSync29(file))
+  const file = join39(resolveStorageUsersLogDir(), String(userId), "sent-files.jsonl");
+  if (!existsSync30(file))
     return;
   try {
     const remaining = readJsonlLines(file).filter((line) => {
@@ -28429,7 +28255,7 @@ var init_storage_public = __esm(async () => {
 });
 
 // ../../packages/mcp/src/hosted-surfaces.ts
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 function isActiveHostedMcpSurface(surface) {
   return ACTIVE_HOSTED_MCP_SURFACES.includes(surface);
 }
@@ -28486,23 +28312,11 @@ async function buildHostedSurfaceServer(surface, context) {
       });
     }
     case "vault": {
-      const [{ createVaultMcpServer: createVaultMcpServer2 }, vault, { logger: logger2 }] = await Promise.all([
+      const [{ createVaultMcpServer: createVaultMcpServer2 }, vault] = await Promise.all([
         Promise.resolve().then(() => (init_vault2(), exports_vault)),
-        init_vault_public().then(() => exports_vault_public),
-        init_mcp_runtime_host().then(() => exports_mcp_runtime_host)
+        init_vault_public().then(() => exports_vault_public)
       ]);
-      return createVaultMcpServer2({
-        userId: context.userId,
-        listOnly: context.agent !== "codex",
-        cwd: context.cwd
-      }, {
-        list: vault.vaultList,
-        substitute: vault.vaultSubstituteDetailed,
-        redact: vault.redactVaultSecrets,
-        log(level, details, message) {
-          logger2[level](details, message);
-        }
-      });
+      return createVaultMcpServer2({ userId: context.userId }, { list: vault.vaultList });
     }
     case "wiki":
     case "skills": {
@@ -28525,7 +28339,7 @@ async function buildHostedSurfaceServer(surface, context) {
         ...topicId ? { topicId } : {},
         surface
       }, {
-        wikiRoot: resolve18(WORKSPACE_DIR2, "wiki"),
+        wikiRoot: resolve19(WORKSPACE_DIR2, "wiki"),
         getTopicBrief: storage.getTopicBrief,
         resolveTopicBrief: accessibleTopicBrief,
         setTopicBrief: storage.setTopicBrief
@@ -28656,10 +28470,10 @@ var init_sse_transport = () => {};
 // ../../packages/mcp/src/server.ts
 import { createHash as createHash10, randomUUID as randomUUID23 } from "crypto";
 import { realpathSync as realpathSync6, statSync as statSync17 } from "fs";
-import { basename as basename9, extname as extname3, resolve as resolve19 } from "path";
+import { basename as basename9, extname as extname3, resolve as resolve20 } from "path";
 import { McpServer as McpServer8 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 function requireTopicAccess(ctx) {
   const topic = getTopic(ctx.topicId);
   if (!topic)
@@ -28670,8 +28484,8 @@ function requireTopicAccess(ctx) {
   return { topic };
 }
 function isPathInside2(baseDir, filePath) {
-  const cwd = resolve19(baseDir);
-  const normalized = resolve19(filePath);
+  const cwd = resolve20(baseDir);
+  const normalized = resolve20(filePath);
   try {
     const realCwd = realpathSync6(cwd);
     const real = realpathSync6(normalized);
@@ -28687,7 +28501,7 @@ function localFileInfo(ctx, filePath) {
   if (!isPathInside2(ctx.cwd, filePath)) {
     return { error: "Access denied. File must be within the topic workspace." };
   }
-  const normalizedPath = resolve19(filePath);
+  const normalizedPath = resolve20(filePath);
   if (isSensitivePath(normalizedPath)) {
     return { error: "Access denied. Path matches the sensitive-file blacklist." };
   }
@@ -28879,8 +28693,8 @@ function buildNegotiumMcpServer(ctx) {
     }
   }
   if (ctx.fileDeliveryTools === true) {
-    server.tool("send_file", "Send a local file to the user in the chat. Use this when you want to share a file (image, document, PDF, code, etc.) with the user. The file will appear as a downloadable item in the chat.", { file_path: z13.string().describe("Absolute path to the file to send") }, async ({ file_path }) => deliverFile(ctx, file_path));
-    server.tool("send_files", "Send multiple local files to the user in the chat at once.", { file_paths: z13.array(z13.string()).describe("Array of absolute file paths to send") }, async ({ file_paths }) => {
+    server.tool("send_file", "Send a local file to the user in the chat. Use this when you want to share a file (image, document, PDF, code, etc.) with the user. The file will appear as a downloadable item in the chat.", { file_path: z12.string().describe("Absolute path to the file to send") }, async ({ file_path }) => deliverFile(ctx, file_path));
+    server.tool("send_files", "Send multiple local files to the user in the chat at once.", { file_paths: z12.array(z12.string()).describe("Array of absolute file paths to send") }, async ({ file_paths }) => {
       const results = await Promise.all(file_paths.map((filePath) => deliverFile(ctx, filePath)));
       const hasError = results.some((result) => ("isError" in result) && result.isError);
       return {
@@ -29164,37 +28978,37 @@ var init_src2 = __esm(async () => {
 
 // ../../packages/mcp-host/src/paths.ts
 import { homedir as homedir9 } from "os";
-import { resolve as resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 function stateDir() {
   const env = process.env.NEGOTIUM_STATE_DIR?.trim();
-  return env ? resolve20(env) : resolve20(homedir9(), ".negotium");
+  return env ? resolve21(env) : resolve21(homedir9(), ".negotium");
 }
 function defaultPortsDir() {
-  return resolve20(stateDir(), "run", "mcp-ports");
+  return resolve21(stateDir(), "run", "mcp-ports");
 }
 function defaultManifestFile() {
-  return resolve20(stateDir(), "data", "mcp-manifest.json");
+  return resolve21(stateDir(), "data", "mcp-manifest.json");
 }
 var init_paths = () => {};
 
 // ../../packages/mcp-host/src/spec.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var KEY_PATTERN, portSchema, mcpServerSpecSchema;
 var init_spec = __esm(() => {
   KEY_PATTERN = /^[a-zA-Z0-9._-]+$/;
-  portSchema = z14.number().int().min(1).max(65535);
-  mcpServerSpecSchema = z14.object({
-    key: z14.string().min(1).regex(KEY_PATTERN, "key may only contain [a-zA-Z0-9._-]").refine((k) => k !== "." && k !== "..", "key may not be a dot path"),
-    transport: z14.enum(["stdio", "http"]),
-    command: z14.string().min(1),
-    args: z14.array(z14.string()).optional(),
-    env: z14.record(z14.string(), z14.string()).optional(),
-    cwd: z14.string().optional(),
-    portRange: z14.object({ base: portSchema, max: portSchema }).optional(),
-    scope: z14.enum(["node", "instance"]),
-    readyTimeoutMs: z14.number().int().positive().optional(),
-    idleEvictMs: z14.number().int().positive().optional(),
-    healthIntervalMs: z14.number().int().positive().optional()
+  portSchema = z13.number().int().min(1).max(65535);
+  mcpServerSpecSchema = z13.object({
+    key: z13.string().min(1).regex(KEY_PATTERN, "key may only contain [a-zA-Z0-9._-]").refine((k) => k !== "." && k !== "..", "key may not be a dot path"),
+    transport: z13.enum(["stdio", "http"]),
+    command: z13.string().min(1),
+    args: z13.array(z13.string()).optional(),
+    env: z13.record(z13.string(), z13.string()).optional(),
+    cwd: z13.string().optional(),
+    portRange: z13.object({ base: portSchema, max: portSchema }).optional(),
+    scope: z13.enum(["node", "instance"]),
+    readyTimeoutMs: z13.number().int().positive().optional(),
+    idleEvictMs: z13.number().int().positive().optional(),
+    healthIntervalMs: z13.number().int().positive().optional()
   }).superRefine((spec, ctx) => {
     if (spec.transport === "http") {
       if (!spec.portRange) {
@@ -29215,9 +29029,9 @@ var init_spec = __esm(() => {
 });
 
 // ../../packages/mcp-host/src/manifest.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync27, readFileSync as readFileSync25, renameSync as renameSync14, writeFileSync as writeFileSync21 } from "fs";
-import { dirname as dirname18 } from "path";
-import { z as z15 } from "zod";
+import { existsSync as existsSync31, mkdirSync as mkdirSync27, readFileSync as readFileSync25, renameSync as renameSync14, writeFileSync as writeFileSync21 } from "fs";
+import { dirname as dirname19 } from "path";
+import { z as z14 } from "zod";
 
 class McpManifest {
   file;
@@ -29260,7 +29074,7 @@ class McpManifest {
     return this.entries.get(key)?.enabled ?? false;
   }
   load() {
-    if (!existsSync30(this.file))
+    if (!existsSync31(this.file))
       return;
     let parsed;
     try {
@@ -29276,7 +29090,7 @@ class McpManifest {
     }
   }
   save() {
-    mkdirSync27(dirname18(this.file), { recursive: true });
+    mkdirSync27(dirname19(this.file), { recursive: true });
     const payload = {
       version: 1,
       servers: [...this.entries.values()]
@@ -29291,13 +29105,13 @@ var manifestEntrySchema, manifestFileSchema;
 var init_manifest = __esm(() => {
   init_paths();
   init_spec();
-  manifestEntrySchema = z15.object({
+  manifestEntrySchema = z14.object({
     spec: mcpServerSpecSchema,
-    enabled: z15.boolean()
+    enabled: z14.boolean()
   });
-  manifestFileSchema = z15.object({
-    version: z15.literal(1),
-    servers: z15.array(manifestEntrySchema)
+  manifestFileSchema = z14.object({
+    version: z14.literal(1),
+    servers: z14.array(manifestEntrySchema)
   });
 });
 
@@ -29310,7 +29124,7 @@ function sanitizePathComponent(name) {
 }
 
 // ../../packages/mcp-host/src/manager.ts
-import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
+import { execFileSync as execFileSync8, spawn as spawn7 } from "child_process";
 import {
   mkdirSync as mkdirSync28,
   readdirSync as readdirSync12,
@@ -29319,8 +29133,8 @@ import {
   unlinkSync as unlinkSync21,
   writeFileSync as writeFileSync22
 } from "fs";
-import { connect, createServer as createServer3 } from "net";
-import { join as join39 } from "path";
+import { connect, createServer as createServer4 } from "net";
+import { join as join40 } from "path";
 function regKey(key, instanceKey) {
   return `${key}\x00${instanceKey}`;
 }
@@ -29336,16 +29150,16 @@ function resolveInstanceKey(spec, instanceKey) {
   return instanceKey;
 }
 function canBind(port) {
-  return new Promise((resolve21) => {
-    const srv = createServer3();
-    srv.once("error", () => resolve21(false));
+  return new Promise((resolve22) => {
+    const srv = createServer4();
+    srv.once("error", () => resolve22(false));
     srv.listen({ port, host: "127.0.0.1", exclusive: true }, () => {
-      srv.close(() => resolve21(true));
+      srv.close(() => resolve22(true));
     });
   });
 }
 function tcpProbe(port, timeoutMs = PROBE_TIMEOUT_MS2) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve22) => {
     const sock = connect({ port, host: "127.0.0.1" });
     let settled = false;
     const done = (ok3) => {
@@ -29353,7 +29167,7 @@ function tcpProbe(port, timeoutMs = PROBE_TIMEOUT_MS2) {
         return;
       settled = true;
       sock.destroy();
-      resolve21(ok3);
+      resolve22(ok3);
     };
     sock.once("connect", () => done(true));
     sock.once("error", () => done(false));
@@ -29381,12 +29195,12 @@ function killProcessTree(pid) {
 function waitExit(proc, timeoutMs) {
   if (proc.exitCode !== null || proc.signalCode !== null)
     return Promise.resolve(true);
-  return new Promise((resolve21) => {
-    const timer = setTimeout(() => resolve21(false), timeoutMs);
+  return new Promise((resolve22) => {
+    const timer = setTimeout(() => resolve22(false), timeoutMs);
     timer.unref?.();
     const settle = () => {
       clearTimeout(timer);
-      resolve21(true);
+      resolve22(true);
     };
     proc.once("exit", settle);
     proc.once("error", settle);
@@ -29520,7 +29334,7 @@ class McpHost {
     let spawnFailed = false;
     let proc;
     try {
-      proc = spawn8(spec.command, args, {
+      proc = spawn7(spec.command, args, {
         stdio: "ignore",
         detached: false,
         cwd: spec.cwd,
@@ -29622,7 +29436,7 @@ class McpHost {
       if (file.includes(".tmp-"))
         continue;
       try {
-        const port = Number.parseInt(readFileSync26(join39(this.portsDir, file), "utf8").trim(), 10);
+        const port = Number.parseInt(readFileSync26(join40(this.portsDir, file), "utf8").trim(), 10);
         if (!Number.isNaN(port))
           claims.set(file, port);
       } catch {}
@@ -29632,7 +29446,7 @@ class McpHost {
   writePortFile(fileName, port) {
     try {
       mkdirSync28(this.portsDir, { recursive: true });
-      const file = join39(this.portsDir, fileName);
+      const file = join40(this.portsDir, fileName);
       const tmp = `${file}.tmp-${process.pid}`;
       writeFileSync22(tmp, String(port));
       renameSync15(tmp, file);
@@ -29642,7 +29456,7 @@ class McpHost {
   }
   deletePortFile(fileName) {
     try {
-      unlinkSync21(join39(this.portsDir, fileName));
+      unlinkSync21(join40(this.portsDir, fileName));
     } catch {}
   }
   cleanupRunning(rkey, inst) {
@@ -29729,7 +29543,7 @@ var DEFAULT_READY_TIMEOUT_MS = 20000, READY_POLL_MS = 150, KILL_GRACE_MS = 5000,
     fn(`[mcp-host] ${msg}`, ctx);
   else
     fn(`[mcp-host] ${msg}`);
-}, delay2 = (ms) => new Promise((resolve21) => setTimeout(resolve21, ms));
+}, delay2 = (ms) => new Promise((resolve22) => setTimeout(resolve22, ms));
 var init_manager3 = __esm(() => {
   init_manifest();
   init_paths();
@@ -29747,14 +29561,14 @@ var init_src3 = __esm(() => {
 import { randomUUID as randomUUID24 } from "crypto";
 import {
   copyFileSync as copyFileSync4,
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   mkdirSync as mkdirSync29,
   readFileSync as readFileSync27,
   rmSync as rmSync9,
   statSync as statSync18,
   writeFileSync as writeFileSync23
 } from "fs";
-import { basename as basename10, extname as extname4, join as join40 } from "path";
+import { basename as basename10, extname as extname4, join as join41 } from "path";
 function safeExtension(filename) {
   const extension = extname4(basename10(filename));
   return /^\.[A-Za-z0-9]{1,16}$/.test(extension) ? extension.toLowerCase() : "";
@@ -29772,14 +29586,14 @@ function contentDisposition(filename) {
 
 class NodeFileStore {
   uploadDir;
-  constructor(uploadDir = join40(DATA_DIR, "uploads")) {
+  constructor(uploadDir = join41(DATA_DIR, "uploads")) {
     this.uploadDir = uploadDir;
   }
   #ensureDir() {
     mkdirSync29(this.uploadDir, { recursive: true });
   }
   #metadataPath(fileId) {
-    return join40(this.uploadDir, `${fileId}.meta.json`);
+    return join41(this.uploadDir, `${fileId}.meta.json`);
   }
   #metadata(fileId) {
     if (!FILE_ID_RE.test(fileId))
@@ -29808,7 +29622,7 @@ class NodeFileStore {
   hooks = {
     resolveAttachmentByFileId: (fileId) => {
       const metadata = this.#metadata(fileId);
-      if (!metadata || !existsSync31(join40(this.uploadDir, metadata.savedName)))
+      if (!metadata || !existsSync32(join41(this.uploadDir, metadata.savedName)))
         return null;
       return this.#attachment(fileId, metadata);
     },
@@ -29816,8 +29630,8 @@ class NodeFileStore {
       const metadata = this.#metadata(fileId);
       if (!metadata)
         return null;
-      const path = join40(this.uploadDir, metadata.savedName);
-      return existsSync31(path) ? path : null;
+      const path = join41(this.uploadDir, metadata.savedName);
+      return existsSync32(path) ? path : null;
     },
     storeLocalFileAsUpload: (absPath, access = {}) => this.store(absPath, access),
     deleteFilesForTopic: (topicId) => this.deleteForTopic(topicId)
@@ -29831,11 +29645,11 @@ class NodeFileStore {
     const mimeType = file.type || MIME_BY_EXT2[extension] || "application/octet-stream";
     const existing = this.#metadata(fileId);
     if (existing) {
-      const matches = existing.filename === filename && existing.mimeType === mimeType && existing.sizeBytes === file.size && existing.ownerUserId === access.ownerUserId && existing.topicId === access.topicId && existsSync31(join40(this.uploadDir, existing.savedName));
+      const matches = existing.filename === filename && existing.mimeType === mimeType && existing.sizeBytes === file.size && existing.ownerUserId === access.ownerUserId && existing.topicId === access.topicId && existsSync32(join41(this.uploadDir, existing.savedName));
       return matches ? this.#attachment(fileId, existing) : null;
     }
     const savedName = `${fileId}${extension}`;
-    const savedPath = join40(this.uploadDir, savedName);
+    const savedPath = join41(this.uploadDir, savedName);
     try {
       const sizeBytes = await Bun.write(savedPath, file);
       if (sizeBytes !== file.size)
@@ -29860,14 +29674,14 @@ class NodeFileStore {
   }
   allows(fileId, access) {
     const metadata = this.#metadata(fileId);
-    return Boolean(metadata && metadata.ownerUserId === access.ownerUserId && metadata.topicId === access.topicId && existsSync31(join40(this.uploadDir, metadata.savedName)));
+    return Boolean(metadata && metadata.ownerUserId === access.ownerUserId && metadata.topicId === access.topicId && existsSync32(join41(this.uploadDir, metadata.savedName)));
   }
   store(absPath, access = {}) {
     this.#ensureDir();
     const fileId = randomUUID24();
     const extension = safeExtension(absPath);
     const savedName = `${fileId}${extension}`;
-    const savedPath = join40(this.uploadDir, savedName);
+    const savedPath = join41(this.uploadDir, savedName);
     try {
       const stats = statSync18(absPath);
       if (!stats.isFile() || stats.size > MAX_NODE_UPLOAD_BYTES)
@@ -29899,8 +29713,8 @@ class NodeFileStore {
     const allowed = metadata.visibility === "workspace" || metadata.ownerUserId === userId || Boolean(topic && isParticipant(topic, userId));
     if (!allowed)
       return null;
-    const path = join40(this.uploadDir, metadata.savedName);
-    if (!existsSync31(path))
+    const path = join41(this.uploadDir, metadata.savedName);
+    if (!existsSync32(path))
       return null;
     return new Response(Bun.file(path), {
       headers: {
@@ -29918,7 +29732,7 @@ class NodeFileStore {
       const metadata = this.#metadata(fileId);
       if (metadata?.topicId !== topicId)
         continue;
-      rmSync9(join40(this.uploadDir, metadata.savedName), { force: true });
+      rmSync9(join41(this.uploadDir, metadata.savedName), { force: true });
       rmSync9(this.#metadataPath(fileId), { force: true });
     }
   }
@@ -30070,14 +29884,14 @@ function createPollingSseStream(req, options) {
 import { randomUUID as randomUUID25, timingSafeEqual as timingSafeEqual4 } from "crypto";
 import {
   chmodSync as chmodSync6,
-  existsSync as existsSync32,
+  existsSync as existsSync33,
   mkdirSync as mkdirSync30,
   readFileSync as readFileSync28,
   renameSync as renameSync16,
   unlinkSync as unlinkSync22,
   writeFileSync as writeFileSync24
 } from "fs";
-import { dirname as dirname19, resolve as resolve21 } from "path";
+import { dirname as dirname20, resolve as resolve22 } from "path";
 function jsonError(status, error2) {
   return Response.json({ ok: false, error: error2 }, { status });
 }
@@ -30906,7 +30720,7 @@ function writeNodeDaemonInfo(port, startedAt) {
     stateDir: STATE_DIR,
     startedAt
   };
-  mkdirSync30(dirname19(NODE_DAEMON_INFO_PATH), { recursive: true });
+  mkdirSync30(dirname20(NODE_DAEMON_INFO_PATH), { recursive: true });
   const temporary = `${NODE_DAEMON_INFO_PATH}.${process.pid}.${randomUUID25()}.tmp`;
   writeFileSync24(temporary, `${JSON.stringify(info, null, 2)}
 `, { mode: 384 });
@@ -30916,7 +30730,7 @@ function writeNodeDaemonInfo(port, startedAt) {
   return info;
 }
 function readNodeDaemonInfo() {
-  if (!existsSync32(NODE_DAEMON_INFO_PATH))
+  if (!existsSync33(NODE_DAEMON_INFO_PATH))
     return null;
   try {
     const value = JSON.parse(readFileSync28(NODE_DAEMON_INFO_PATH, "utf8"));
@@ -31001,7 +30815,7 @@ var init_control = __esm(async () => {
   await init_node_host();
   await init_files();
   NODE_RUNTIME_CONTRACT_BASE_PATH = `${NODE_CONTROL_BASE_PATH}/runtime/v1`;
-  NODE_DAEMON_INFO_PATH = resolve21(RUN_DIR, "node-daemon.json");
+  NODE_DAEMON_INFO_PATH = resolve22(RUN_DIR, "node-daemon.json");
   NODE_VERSION = NEGOTIUM_VERSION;
   ControlRequestError = class ControlRequestError extends Error {
     constructor(message) {
@@ -31202,9 +31016,9 @@ var init_schedule = __esm(() => {
 });
 
 // ../../packages/module-cron/src/scripts.ts
-import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync33, mkdirSync as mkdirSync31, readdirSync as readdirSync13 } from "fs";
-import { resolve as resolve22, sep as sep2 } from "path";
+import { spawn as spawn8 } from "child_process";
+import { existsSync as existsSync34, mkdirSync as mkdirSync31, readdirSync as readdirSync13 } from "fs";
+import { resolve as resolve23, sep as sep2 } from "path";
 function validateCronScriptName(script) {
   if (!/^[A-Za-z0-9_][A-Za-z0-9_.-]*\.py$/.test(script) || script.includes("..") || script.includes("/") || script.includes("\\")) {
     return { ok: false, error: `script must be a plain .py filename under ${CRON_JOBS_DIR}` };
@@ -31215,7 +31029,7 @@ function resolveCronScriptPath(script) {
   const valid = validateCronScriptName(script);
   if (!valid.ok)
     throw new Error(valid.error);
-  const path = resolve22(CRON_JOBS_DIR, script);
+  const path = resolve23(CRON_JOBS_DIR, script);
   if (!path.startsWith(`${CRON_JOBS_DIR}${sep2}`))
     throw new Error("script path escaped jobs directory");
   return path;
@@ -31226,7 +31040,7 @@ function listCronScripts() {
 }
 function cronScriptExists(script) {
   try {
-    return existsSync33(resolveCronScriptPath(script));
+    return existsSync34(resolveCronScriptPath(script));
   } catch {
     return false;
   }
@@ -31258,14 +31072,14 @@ async function runCronPromptScript(options) {
   if (options.signal?.aborted)
     throw new CronScriptError("script run aborted");
   const scriptPath = resolveCronScriptPath(options.script);
-  if (!existsSync33(scriptPath))
+  if (!existsSync34(scriptPath))
     throw new CronScriptError(`cron script not found: ${options.script}`);
   const timeoutMs = Math.max(5000, options.timeoutMs ?? DEFAULT_SCRIPT_TIMEOUT_MS);
   const outputLimitBytes = Math.max(1024, options.outputLimitBytes ?? DEFAULT_OUTPUT_LIMIT_BYTES);
   const command = commandForScript(scriptPath);
   let child;
   try {
-    child = spawn9(command.executable, command.args, {
+    child = spawn8(command.executable, command.args, {
       cwd: options.cwd,
       detached: true,
       env: {
@@ -31331,7 +31145,7 @@ async function runCronPromptScript(options) {
 var CRON_JOBS_DIR, DEFAULT_SCRIPT_TIMEOUT_MS, DEFAULT_OUTPUT_LIMIT_BYTES, KILL_GRACE_MS2 = 2500, CronScriptError;
 var init_scripts = __esm(async () => {
   await init_cron_host();
-  CRON_JOBS_DIR = resolve22(process.env.NEGOTIUM_CRON_JOBS_DIR?.trim() || resolve22(WORKSPACE_DIR, "cron", "jobs"));
+  CRON_JOBS_DIR = resolve23(process.env.NEGOTIUM_CRON_JOBS_DIR?.trim() || resolve23(WORKSPACE_DIR, "cron", "jobs"));
   DEFAULT_SCRIPT_TIMEOUT_MS = 10 * 60000;
   DEFAULT_OUTPUT_LIMIT_BYTES = 1024 * 1024;
   CronScriptError = class CronScriptError extends Error {
@@ -32451,8 +32265,8 @@ var init_scheduler = __esm(async () => {
 });
 
 // ../../packages/module-cron/src/module.ts
-import { existsSync as existsSync34 } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync35 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function envMs(name, fallback) {
   const parsed = Number.parseInt(process.env[name] ?? "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -32482,7 +32296,7 @@ function createCronModule(options = {}) {
         if (event.type === "topic-deleted")
           trackCleanup(resetCronTopicContext(event.topicId));
       });
-      const mcpServerFile = options.mcpServerFile ?? (existsSync34(SOURCE_MCP_SERVER_FILE) ? SOURCE_MCP_SERVER_FILE : PACKAGED_MCP_SERVER_FILE);
+      const mcpServerFile = options.mcpServerFile ?? (existsSync35(SOURCE_MCP_SERVER_FILE) ? SOURCE_MCP_SERVER_FILE : PACKAGED_MCP_SERVER_FILE);
       const unregisterMcp = host2.registerRuntimeMcpServer("cron-manager", {
         scopes: ["forum", "manager"],
         forumRequired: true,
@@ -32575,8 +32389,8 @@ var init_module = __esm(async () => {
   await init_scheduler();
   await init_scripts();
   await init_store();
-  SOURCE_MCP_SERVER_FILE = fileURLToPath2(new URL("./mcp-server.ts", import.meta.url));
-  PACKAGED_MCP_SERVER_FILE = fileURLToPath2(new URL("./runtime/cron/mcp-server.ts", import.meta.url));
+  SOURCE_MCP_SERVER_FILE = fileURLToPath3(new URL("./mcp-server.ts", import.meta.url));
+  PACKAGED_MCP_SERVER_FILE = fileURLToPath3(new URL("./runtime/cron/mcp-server.ts", import.meta.url));
 });
 
 // ../../packages/module-cron/src/summarize.ts
@@ -32762,10 +32576,10 @@ __export(exports_src3, {
   NODE_CONTROL_PROTOCOL_VERSION: () => NODE_CONTROL_PROTOCOL_VERSION,
   NODE_CONTROL_BASE_PATH: () => NODE_CONTROL_BASE_PATH
 });
-import { createServer as createServer4 } from "net";
+import { createServer as createServer5 } from "net";
 async function availableLoopbackPort() {
-  return new Promise((resolve23, reject) => {
-    const probe = createServer4();
+  return new Promise((resolve24, reject) => {
+    const probe = createServer5();
     probe.unref();
     probe.once("error", reject);
     probe.listen(0, "127.0.0.1", () => {
@@ -32775,7 +32589,7 @@ async function availableLoopbackPort() {
         if (error2)
           reject(error2);
         else if (port > 0)
-          resolve23(port);
+          resolve24(port);
         else
           reject(new Error("failed to allocate a loopback port"));
       });
@@ -32914,8 +32728,8 @@ function startNode(opts = {}) {
   const manifest = new McpManifest;
   const stopSweeper = mcpHost.startSweeper();
   let resolveCompleted;
-  const completed = new Promise((resolve23) => {
-    resolveCompleted = resolve23;
+  const completed = new Promise((resolve24) => {
+    resolveCompleted = resolve24;
   });
   let advertised = null;
   try {
@@ -32994,7 +32808,7 @@ async function runNodeDaemon(opts = {}) {
     singleton: true
   });
   await node.completed;
-  await new Promise((resolve23) => setImmediate(resolve23));
+  await new Promise((resolve24) => setImmediate(resolve24));
   process.exit(0);
 }
 var init_src5 = __esm(async () => {
@@ -34040,9 +33854,9 @@ var init_context_usage = __esm(async () => {
 
 // ../../adapters/terminal/src/path-suggest.ts
 import { execFile as execFile3 } from "child_process";
-import { existsSync as existsSync35, readdirSync as readdirSync14, statSync as statSync19 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync14, statSync as statSync19 } from "fs";
 import { homedir as homedir10 } from "os";
-import { basename as basename11, dirname as dirname20, join as join41, sep as sep3 } from "path";
+import { basename as basename11, dirname as dirname21, join as join42, sep as sep3 } from "path";
 import { promisify as promisify3 } from "util";
 function indexRecursivePaths(files) {
   const paths = [];
@@ -34143,15 +33957,15 @@ function resolveFragment(frag) {
   else if (frag === "~/")
     path = home;
   else if (frag.startsWith("~/"))
-    path = join41(home, frag.slice(2));
+    path = join42(home, frag.slice(2));
   else if (frag.startsWith("/"))
     path = frag;
   else
-    path = join41(home, frag);
+    path = join42(home, frag);
   if (frag.endsWith("/") || frag === "" || frag === "~") {
     return { dir: path, prefix: "" };
   }
-  return { dir: dirname20(path), prefix: basename11(path) };
+  return { dir: dirname21(path), prefix: basename11(path) };
 }
 function toToken(fullPath, isDir) {
   const home = homedir10();
@@ -34176,7 +33990,7 @@ function rankAndSlice(dir, candidates) {
   });
   return candidates.slice(0, MAX_SUGGESTIONS).map(({ relPath, isDir }) => ({
     label: `${relPath}${isDir ? "/" : ""}`,
-    value: toToken(join41(dir, relPath), isDir),
+    value: toToken(join42(dir, relPath), isDir),
     isDir
   }));
 }
@@ -34255,7 +34069,7 @@ function pathSuggestions(lineText, col) {
     let isDir = entry.isDirectory();
     if (!isDir && entry.isSymbolicLink()) {
       try {
-        isDir = statSync19(join41(dir, entry.name)).isDirectory();
+        isDir = statSync19(join42(dir, entry.name)).isDirectory();
       } catch {}
     }
     return {
@@ -34282,14 +34096,14 @@ function fragmentToAbsolutePath(frag) {
   if (frag === "~" || frag === "~/")
     return home;
   if (frag.startsWith("~/"))
-    return join41(home, frag.slice(2));
+    return join42(home, frag.slice(2));
   if (frag.startsWith("/"))
     return frag;
-  return join41(home, frag);
+  return join42(home, frag);
 }
 function fragmentResolves(frag) {
   try {
-    return existsSync35(fragmentToAbsolutePath(frag));
+    return existsSync36(fragmentToAbsolutePath(frag));
   } catch {
     return false;
   }
@@ -38193,8 +38007,8 @@ class TerminalApp {
         this.#refreshBackgroundSessions();
       }, 1000);
       this.#backgroundRefreshTimer.unref?.();
-      await new Promise((resolve23) => {
-        this.#finishRun = resolve23;
+      await new Promise((resolve24) => {
+        this.#finishRun = resolve24;
       });
     } finally {
       this.#running = false;
@@ -40791,7 +40605,7 @@ var init_commands2 = __esm(async () => {
 // ../../adapters/telegram/src/mapping-store.ts
 import { Database as Database2 } from "bun:sqlite";
 import { mkdirSync as mkdirSync32 } from "fs";
-import { dirname as dirname21, join as join42 } from "path";
+import { dirname as dirname22, join as join43 } from "path";
 function outboxRowToEntry(row) {
   return {
     id: row.id,
@@ -40857,9 +40671,9 @@ function migrateOutboxSchema(db4) {
   db4.run("CREATE INDEX IF NOT EXISTS idx_telegram_outbox_runtime_message ON outbox(runtime_message_id)");
 }
 function openMappingStore(path) {
-  const dbPath = path ?? join42(DATA_DIR, "adapter-telegram.db");
+  const dbPath = path ?? join43(DATA_DIR, "adapter-telegram.db");
   if (dbPath !== ":memory:")
-    mkdirSync32(dirname21(dbPath), { recursive: true });
+    mkdirSync32(dirname22(dbPath), { recursive: true });
   const db4 = new Database2(dbPath);
   migrateLegacySchema(db4);
   createTables(db4);
@@ -41094,8 +40908,8 @@ ${caption}` : voiceText : caption;
       return;
     }
     let release;
-    const ready = new Promise((resolve23) => {
-      release = resolve23;
+    const ready = new Promise((resolve24) => {
+      release = resolve24;
     });
     const entry = {
       messages: [msg],
@@ -41217,7 +41031,7 @@ function renderOutbound(text2, maxLen = 4096) {
 }
 
 // ../../adapters/telegram/src/adapter.ts
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import { basename as basename12, extname as extname5 } from "path";
 function startTelegramAdapter(opts) {
   const { client, forumChatId } = opts;
@@ -41328,7 +41142,7 @@ function startTelegramAdapter(opts) {
           attempt += 1;
           const waitMs = Math.min(5000, 250 * 2 ** Math.min(attempt - 1, 5));
           logger.warn({ err: err2, attempt, waitMs }, "telegram adapter: getMe failed while resolving onboarding identity; retrying");
-          await new Promise((resolve23) => setTimeout(resolve23, waitMs));
+          await new Promise((resolve24) => setTimeout(resolve24, waitMs));
         }
       }
       return;
@@ -41715,7 +41529,7 @@ function startTelegramAdapter(opts) {
       logger.warn({ path, chatId }, "telegram adapter: blocked sensitive file path");
       return { ref: null, delivered: false, error: "path matches the sensitive-file blacklist" };
     }
-    if (!existsSync36(path)) {
+    if (!existsSync37(path)) {
       const sent = await client.sendMessage(chatId, `File: ${path}`, base).catch(() => null);
       const messageId = sentMessageId(sent);
       return {
@@ -41815,14 +41629,14 @@ function startTelegramAdapter(opts) {
   const sendQueues = new Map;
   function enqueueSend(topicId, task) {
     const prev = sendQueues.get(topicId) ?? Promise.resolve();
-    const next = prev.then(() => new Promise((resolve23) => {
+    const next = prev.then(() => new Promise((resolve24) => {
       const timer = setTimeout(() => {
         logger.warn({ topicId, sendTimeoutMs }, "telegram adapter: send timed out \u2014 abandoning it and continuing the queue");
-        resolve23();
+        resolve24();
       }, sendTimeoutMs);
       task().catch((err2) => logger.warn({ err: err2, topicId }, "telegram adapter: send task failed")).finally(() => {
         clearTimeout(timer);
-        resolve23();
+        resolve24();
       });
     }));
     sendQueues.set(topicId, next);
@@ -42068,7 +41882,7 @@ ${suffix}`;
                 continue;
               }
               if (retryDelayMs > 0) {
-                await new Promise((resolve23) => setTimeout(resolve23, retryDelayMs));
+                await new Promise((resolve24) => setTimeout(resolve24, retryDelayMs));
               }
               try {
                 await client.editMessageText(text2, editOptions);
@@ -42709,8 +42523,8 @@ async function runTelegramCli(args = process.argv.slice(2)) {
   onShutdown("telegram-channel", 100, () => channel.stop());
   onShutdown("telegram-singleton", 90, () => singleton.stop());
   let resolveCompleted;
-  const completed = new Promise((resolve23) => {
-    resolveCompleted = resolve23;
+  const completed = new Promise((resolve24) => {
+    resolveCompleted = resolve24;
   });
   onShutdown("telegram-completed", -100, resolveCompleted);
   process.stdout.write(`negotium Telegram adapter connected to canonical node pid ${initialNode.info?.pid ?? "unknown"}
@@ -42735,11 +42549,11 @@ var exports_join_status = {};
 __export(exports_join_status, {
   hasConfiguredOtiumJoin: () => hasConfiguredOtiumJoin
 });
-import { existsSync as existsSync37 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync38 } from "fs";
+import { resolve as resolve24 } from "path";
 function hasConfiguredOtiumJoin() {
   const envJoin = Boolean(process.env.OTIUM_CENTRAL_URL?.trim() && process.env.OTIUM_CELL_ID?.trim() && process.env.OTIUM_CELL_SECRET?.trim());
-  return envJoin || existsSync37(resolve23(DATA_DIR, "otium-join.json"));
+  return envJoin || existsSync38(resolve24(DATA_DIR, "otium-join.json"));
 }
 var init_join_status = __esm(() => {
   init_config_public();
@@ -42757,9 +42571,9 @@ function firstCell() {
     return cell;
   return null;
 }
-function attachOtiumCentralCell(join43) {
-  cells.set(join43.cellId, {
-    join: join43,
+function attachOtiumCentralCell(join44) {
+  cells.set(join44.cellId, {
+    join: join44,
     nodesCache: null,
     verifyCache: new Map,
     tokenCache: new Map
@@ -42771,10 +42585,10 @@ function detachOtiumCentralCell(cellId) {
 function attachedOtiumCells() {
   return [...cells.values()].map((cell) => cell.join);
 }
-function configureOtiumCentral(join43) {
+function configureOtiumCentral(join44) {
   cells.clear();
-  if (join43)
-    attachOtiumCentralCell(join43);
+  if (join44)
+    attachOtiumCentralCell(join44);
 }
 function isOtiumCentralConfigured() {
   return cells.size > 0;
@@ -43188,7 +43002,7 @@ import { createHash as createHash11, randomUUID as randomUUID28 } from "crypto";
 import {
   chmodSync as chmodSync7,
   closeSync as closeSync5,
-  existsSync as existsSync38,
+  existsSync as existsSync39,
   fsyncSync as fsyncSync2,
   linkSync,
   lstatSync,
@@ -43201,9 +43015,9 @@ import {
   unlinkSync as unlinkSync23,
   writeFileSync as writeFileSync25
 } from "fs";
-import { dirname as dirname22, resolve as resolve24 } from "path";
+import { dirname as dirname23, resolve as resolve25 } from "path";
 function joinFilePath() {
-  return resolve24(DATA_DIR, "otium-join.json");
+  return resolve25(DATA_DIR, "otium-join.json");
 }
 function isHttpUrl(value) {
   return /^https?:\/\//.test(value);
@@ -43258,7 +43072,7 @@ function parseInviteCode(code) {
   return normalizeJoin(parsed);
 }
 function joinLockPath() {
-  return resolve24(DATA_DIR, ".otium-join.lock");
+  return resolve25(DATA_DIR, ".otium-join.lock");
 }
 function processIsAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0)
@@ -43272,9 +43086,9 @@ function processIsAlive(pid) {
 }
 function withJoinCredentialLock(operation) {
   const lockPath = joinLockPath();
-  const ownerPath = resolve24(lockPath, "owner.json");
+  const ownerPath = resolve25(lockPath, "owner.json");
   const owner = { pid: process.pid, token: randomUUID28() };
-  mkdirSync33(dirname22(lockPath), { recursive: true });
+  mkdirSync33(dirname23(lockPath), { recursive: true });
   for (let attempt = 0;; attempt += 1) {
     let created = false;
     try {
@@ -43338,20 +43152,20 @@ function withJoinCredentialLock(operation) {
 function joinsEqual(left, right) {
   return left.central === right.central && left.relay === right.relay && left.cellId === right.cellId && left.secret === right.secret;
 }
-function normalizedJoin(join43) {
+function normalizedJoin(join44) {
   return normalizeJoin({
-    v: join43.v,
-    central: join43.central,
-    relay: join43.relay,
-    cellId: join43.cellId,
-    secret: join43.secret
+    v: join44.v,
+    central: join44.central,
+    relay: join44.relay,
+    cellId: join44.cellId,
+    secret: join44.secret
   });
 }
-function joinCredentialDigest(join43) {
-  return createHash11("sha256").update(JSON.stringify(normalizedJoin(join43))).digest("base64url");
+function joinCredentialDigest(join44) {
+  return createHash11("sha256").update(JSON.stringify(normalizedJoin(join44))).digest("base64url");
 }
 function readPersistedJoins(path = joinFilePath()) {
-  if (!existsSync38(path))
+  if (!existsSync39(path))
     return [];
   const parsed = JSON.parse(readFileSync29(path, "utf-8"));
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -43367,9 +43181,9 @@ function readPersistedJoins(path = joinFilePath()) {
     return normalizeJoin(entry);
   });
 }
-function isJoinPersisted(join43) {
+function isJoinPersisted(join44) {
   try {
-    const normalized = normalizedJoin(join43);
+    const normalized = normalizedJoin(join44);
     return readPersistedJoins().some((persisted) => joinsEqual(persisted, normalized));
   } catch {
     return false;
@@ -43385,8 +43199,8 @@ function fsyncPath(target) {
 }
 function writeJoins(joins, allowOverwrite) {
   const path = joinFilePath();
-  const directory = dirname22(path);
-  const temporaryPath = resolve24(directory, `.otium-join.json.${process.pid}.${randomUUID28()}.tmp`);
+  const directory = dirname23(path);
+  const temporaryPath = resolve25(directory, `.otium-join.json.${process.pid}.${randomUUID28()}.tmp`);
   const payload = { v: JOIN_FILE_VERSION, joins };
   let fd;
   try {
@@ -43407,18 +43221,18 @@ function writeJoins(joins, allowOverwrite) {
   } catch (error2) {
     if (fd !== undefined)
       closeSync5(fd);
-    if (existsSync38(temporaryPath))
+    if (existsSync39(temporaryPath))
       unlinkSync23(temporaryPath);
     throw error2;
   }
   return path;
 }
-function saveJoinWhileLocked(join43, options = {}) {
+function saveJoinWhileLocked(join44, options = {}) {
   const path = joinFilePath();
-  const directory = dirname22(path);
-  const normalized = normalizedJoin(join43);
+  const directory = dirname23(path);
+  const normalized = normalizedJoin(join44);
   mkdirSync33(directory, { recursive: true });
-  if (!existsSync38(path))
+  if (!existsSync39(path))
     return writeJoins([normalized], false);
   if (lstatSync(path).isSymbolicLink()) {
     throw new Error(`refusing to replace symlinked Otium join file at ${path}`);
@@ -43446,13 +43260,13 @@ function saveJoinWhileLocked(join43, options = {}) {
   const next = conflict ? existing.map((persisted) => persisted.cellId === normalized.cellId ? normalized : persisted) : [...existing, normalized];
   return writeJoins(next, true);
 }
-function saveJoin(join43, options = {}) {
-  return withJoinCredentialLock(() => saveJoinWhileLocked(join43, options));
+function saveJoin(join44, options = {}) {
+  return withJoinCredentialLock(() => saveJoinWhileLocked(join44, options));
 }
 function removeJoin(cellId) {
   return withJoinCredentialLock(() => {
     const path = joinFilePath();
-    if (!existsSync38(path))
+    if (!existsSync39(path))
       return false;
     if (lstatSync(path).isSymbolicLink()) {
       throw new Error(`refusing to remove symlinked Otium join file at ${path}`);
@@ -43460,7 +43274,7 @@ function removeJoin(cellId) {
     if (cellId) {
       let remaining;
       try {
-        remaining = readPersistedJoins(path).filter((join43) => join43.cellId !== cellId);
+        remaining = readPersistedJoins(path).filter((join44) => join44.cellId !== cellId);
       } catch {
         return false;
       }
@@ -43472,7 +43286,7 @@ function removeJoin(cellId) {
       }
     }
     unlinkSync23(path);
-    fsyncPath(dirname22(path));
+    fsyncPath(dirname23(path));
     return true;
   });
 }
@@ -43493,7 +43307,7 @@ function loadJoins() {
     logger.warn("otium: OTIUM_CENTRAL_URL, OTIUM_CELL_ID, OTIUM_CELL_SECRET must be set together \u2014 ignoring partial env");
   }
   const path = joinFilePath();
-  if (!existsSync38(path))
+  if (!existsSync39(path))
     return [];
   try {
     return readPersistedJoins(path);
@@ -43513,7 +43327,7 @@ var init_join = __esm(async () => {
 // ../../adapters/otium/src/peer-files.ts
 import { randomUUID as randomUUID29 } from "crypto";
 import { copyFileSync as copyFileSync5, mkdirSync as mkdirSync34, rmSync as rmSync11, statSync as statSync21 } from "fs";
-import { basename as basename13, extname as extname6, join as join43 } from "path";
+import { basename as basename13, extname as extname6, join as join44 } from "path";
 function fileType(mimeType) {
   if (mimeType.startsWith("image/"))
     return "image";
@@ -43579,7 +43393,7 @@ function recordFile(args) {
 function insertLocalFile(args) {
   const id = randomUUID29();
   mkdirSync34(PEER_FILES_DIR, { recursive: true });
-  const path = join43(PEER_FILES_DIR, `${id}-${safeFilename(args.filename)}`);
+  const path = join44(PEER_FILES_DIR, `${id}-${safeFilename(args.filename)}`);
   copyFileSync5(args.sourcePath, path);
   return recordFile({ id, path, sizeBytes: statSync21(path).size, ...args });
 }
@@ -43625,7 +43439,7 @@ function installPeerFileHooks() {
 var PEER_FILES_DIR;
 var init_peer_files = __esm(async () => {
   await init_src();
-  PEER_FILES_DIR = join43(DATA_DIR, "otium-peer-files");
+  PEER_FILES_DIR = join44(DATA_DIR, "otium-peer-files");
   db.exec(`
   CREATE TABLE IF NOT EXISTS otium_peer_files (
     id TEXT PRIMARY KEY,
@@ -44018,14 +43832,14 @@ var init_store2 = __esm(async () => {
 // ../../adapters/otium/src/workspace-scope.ts
 import { createHash as createHash13 } from "crypto";
 import { mkdirSync as mkdirSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync26 } from "fs";
-import { dirname as dirname23, resolve as resolve25 } from "path";
+import { dirname as dirname24, resolve as resolve26 } from "path";
 function surfaceScopeFor(central, workspaceId) {
   const digest = createHash13("sha256").update(`${central.trim().replace(/\/+$/, "")}
 ${workspaceId.trim()}`).digest("hex");
   return `ws_${digest.slice(0, 24)}`;
 }
 function scopeCachePath() {
-  return resolve25(DATA_DIR, "otium-workspace.json");
+  return resolve26(DATA_DIR, "otium-workspace.json");
 }
 function readCache() {
   try {
@@ -44037,19 +43851,19 @@ function readCache() {
     return {};
   }
 }
-function cachedSurfaceScope(join44) {
-  const record = readCache()[join44.cellId];
-  if (!record || record.central !== join44.central || !record.workspaceId)
+function cachedSurfaceScope(join45) {
+  const record = readCache()[join45.cellId];
+  if (!record || record.central !== join45.central || !record.workspaceId)
     return null;
   return surfaceScopeFor(record.central, record.workspaceId);
 }
-function cacheSurfaceScope(join44, workspaceId) {
-  const scope = surfaceScopeFor(join44.central, workspaceId);
+function cacheSurfaceScope(join45, workspaceId) {
+  const scope = surfaceScopeFor(join45.central, workspaceId);
   const path = scopeCachePath();
   try {
-    mkdirSync35(dirname23(path), { recursive: true });
+    mkdirSync35(dirname24(path), { recursive: true });
     const cache = readCache();
-    cache[join44.cellId] = { central: join44.central, workspaceId, scope };
+    cache[join45.cellId] = { central: join45.central, workspaceId, scope };
     writeFileSync26(path, `${JSON.stringify(cache, null, 2)}
 `, { mode: 384 });
   } catch (err2) {
@@ -44057,23 +43871,23 @@ function cacheSurfaceScope(join44, workspaceId) {
   }
   return scope;
 }
-async function resolveSurfaceScope(join44) {
-  const cached = cachedSurfaceScope(join44);
+async function resolveSurfaceScope(join45) {
+  const cached = cachedSurfaceScope(join45);
   if (cached)
     return cached;
   try {
-    const workspaceId = await peerWorkspaceIdForCell(join44.cellId);
+    const workspaceId = await peerWorkspaceIdForCell(join45.cellId);
     if (!workspaceId)
       return null;
-    return cacheSurfaceScope(join44, workspaceId);
+    return cacheSurfaceScope(join45, workspaceId);
   } catch (err2) {
     logger.warn({ err: err2 }, "otium: workspace scope unresolved (will retry on the next contact)");
     return null;
   }
 }
 function surfaceScopeForCell(cellId) {
-  const join44 = attachedOtiumCells().find((candidate) => candidate.cellId === cellId);
-  return join44 ? cachedSurfaceScope(join44) : null;
+  const join45 = attachedOtiumCells().find((candidate) => candidate.cellId === cellId);
+  return join45 ? cachedSurfaceScope(join45) : null;
 }
 function unscopedRoomsAddressable() {
   return attachedOtiumCells().length < 2;
@@ -45086,7 +44900,7 @@ import {
 import {
   chmodSync as chmodSync8,
   closeSync as closeSync6,
-  existsSync as existsSync39,
+  existsSync as existsSync40,
   fsyncSync as fsyncSync3,
   linkSync as linkSync2,
   mkdirSync as mkdirSync36,
@@ -45096,7 +44910,7 @@ import {
   unlinkSync as unlinkSync24,
   writeFileSync as writeFileSync27
 } from "fs";
-import { dirname as dirname24, resolve as resolve26 } from "path";
+import { dirname as dirname25, resolve as resolve27 } from "path";
 function parseEnrollmentInvite(code) {
   let parsed;
   try {
@@ -45117,11 +44931,11 @@ function parseEnrollmentInvite(code) {
   return { v: 2, central, token };
 }
 function pendingEnrollmentPath() {
-  return resolve26(DATA_DIR, "otium-enrollment-pending.json");
+  return resolve27(DATA_DIR, "otium-enrollment-pending.json");
 }
 function isEnrollmentPending(invite) {
   const path = pendingEnrollmentPath();
-  if (!existsSync39(path))
+  if (!existsSync40(path))
     return false;
   try {
     const saved = JSON.parse(readFileSync31(path, "utf8"));
@@ -45132,7 +44946,7 @@ function isEnrollmentPending(invite) {
 }
 function loadOrCreatePending(invite, nodeName) {
   const path = pendingEnrollmentPath();
-  if (existsSync39(path)) {
+  if (existsSync40(path)) {
     const saved = JSON.parse(readFileSync31(path, "utf8"));
     if (saved.central === invite.central && saved.token === invite.token)
       return saved;
@@ -45146,8 +44960,8 @@ function loadOrCreatePending(invite, nodeName) {
     publicKey: pair.publicKey.export({ format: "der", type: "spki" }).toString("base64url"),
     ...nodeName ? { nodeName } : {}
   };
-  mkdirSync36(dirname24(path), { recursive: true });
-  const temporaryPath = resolve26(dirname24(path), `.otium-enrollment-pending.json.${process.pid}.${randomUUID31()}.tmp`);
+  mkdirSync36(dirname25(path), { recursive: true });
+  const temporaryPath = resolve27(dirname25(path), `.otium-enrollment-pending.json.${process.pid}.${randomUUID31()}.tmp`);
   let fd;
   try {
     fd = openSync6(temporaryPath, "wx", 384);
@@ -45159,7 +44973,7 @@ function loadOrCreatePending(invite, nodeName) {
     linkSync2(temporaryPath, path);
     unlinkSync24(temporaryPath);
     chmodSync8(path, 384);
-    const directoryFd = openSync6(dirname24(path), "r");
+    const directoryFd = openSync6(dirname25(path), "r");
     try {
       fsyncSync3(directoryFd);
     } finally {
@@ -45168,9 +44982,9 @@ function loadOrCreatePending(invite, nodeName) {
   } catch (error2) {
     if (fd !== undefined)
       closeSync6(fd);
-    if (existsSync39(temporaryPath))
+    if (existsSync40(temporaryPath))
       unlinkSync24(temporaryPath);
-    if (error2.code === "EEXIST" && existsSync39(path)) {
+    if (error2.code === "EEXIST" && existsSync40(path)) {
       const saved = JSON.parse(readFileSync31(path, "utf8"));
       if (saved.central === invite.central && saved.token === invite.token)
         return saved;
@@ -45181,8 +44995,8 @@ function loadOrCreatePending(invite, nodeName) {
 }
 function replacePendingEnrollment(pending2) {
   const path = pendingEnrollmentPath();
-  const directory = dirname24(path);
-  const temporaryPath = resolve26(directory, `.otium-enrollment-pending.json.${process.pid}.${randomUUID31()}.tmp`);
+  const directory = dirname25(path);
+  const temporaryPath = resolve27(directory, `.otium-enrollment-pending.json.${process.pid}.${randomUUID31()}.tmp`);
   let fd;
   try {
     fd = openSync6(temporaryPath, "wx", 384);
@@ -45201,18 +45015,18 @@ function replacePendingEnrollment(pending2) {
   } catch (error2) {
     if (fd !== undefined)
       closeSync6(fd);
-    if (existsSync39(temporaryPath))
+    if (existsSync40(temporaryPath))
       unlinkSync24(temporaryPath);
     throw error2;
   }
 }
-function recordClaimedCredential(pending2, join44) {
+function recordClaimedCredential(pending2, join45) {
   withJoinCredentialLock(() => {
     const current3 = JSON.parse(readFileSync31(pendingEnrollmentPath(), "utf8"));
     if (current3.central !== pending2.central || current3.token !== pending2.token || current3.idempotencyKey !== pending2.idempotencyKey || current3.publicKey !== pending2.publicKey) {
       throw new Error("pending Otium enrollment changed while its claim was in flight");
     }
-    const claimed = { digest: joinCredentialDigest(join44), cellId: join44.cellId };
+    const claimed = { digest: joinCredentialDigest(join45), cellId: join45.cellId };
     if (current3.claimed && (current3.claimed.digest !== claimed.digest || current3.claimed.cellId !== claimed.cellId)) {
       throw new Error("central returned different credentials for an idempotent enrollment claim");
     }
@@ -45270,36 +45084,36 @@ async function claimEnrollment(invite, nodeName) {
   const secret = openCredential(credential, pending2.privateKey);
   if (!secret.startsWith("rcs_"))
     throw new Error("central returned an invalid runtime credential");
-  const join44 = {
+  const join45 = {
     v: 2,
     central: invite.central,
     relay: String(response.relayUrl),
     cellId: String(response.cell?.id),
     secret
   };
-  if (!join44.relay || !join44.cellId || join44.cellId === "undefined") {
+  if (!join45.relay || !join45.cellId || join45.cellId === "undefined") {
     throw new Error("central returned an incomplete enrollment response");
   }
-  assertSecureRelayUrl(join44.relay);
-  recordClaimedCredential(pending2, join44);
-  return join44;
+  assertSecureRelayUrl(join45.relay);
+  recordClaimedCredential(pending2, join45);
+  return join45;
 }
-function commitEnrollment(join44, options = {}) {
+function commitEnrollment(join45, options = {}) {
   return withJoinCredentialLock(() => {
     const pendingPath = pendingEnrollmentPath();
-    const pending2 = existsSync39(pendingPath) ? JSON.parse(readFileSync31(pendingPath, "utf8")) : null;
-    const digest = joinCredentialDigest(join44);
-    if (pending2 && (!pending2.claimed || pending2.claimed.digest !== digest || pending2.claimed.cellId !== join44.cellId)) {
+    const pending2 = existsSync40(pendingPath) ? JSON.parse(readFileSync31(pendingPath, "utf8")) : null;
+    const digest = joinCredentialDigest(join45);
+    if (pending2 && (!pending2.claimed || pending2.claimed.digest !== digest || pending2.claimed.cellId !== join45.cellId)) {
       throw new Error(`pending Otium enrollment at ${pendingPath} does not match these credentials`);
     }
-    const path = saveJoinWhileLocked(join44, options);
-    if (!isJoinPersisted(join44)) {
+    const path = saveJoinWhileLocked(join45, options);
+    if (!isJoinPersisted(join45)) {
       throw new Error("Otium join credentials were not durably persisted");
     }
     if (!pending2)
       return path;
     unlinkSync24(pendingPath);
-    const directoryFd = openSync6(dirname24(pendingPath), "r");
+    const directoryFd = openSync6(dirname25(pendingPath), "r");
     try {
       fsyncSync3(directoryFd);
     } finally {
@@ -45887,24 +45701,24 @@ function refreshDefaultSurfaceScope() {
   setSurfaceScopeRequired(scopes.length > 1);
 }
 function startOtiumNodeRuntime(options) {
-  const { join: join44 } = options;
-  attachOtiumCentralCell(join44);
+  const { join: join45 } = options;
+  attachOtiumCentralCell(join45);
   const releaseGlobals = acquireGlobalOtiumServices();
   let stopped = false;
-  logger.info({ central: join44.central, cellId: join44.cellId }, "otium: worker mode enabled");
-  mountedScopes.set(join44.cellId, cachedSurfaceScope(join44));
+  logger.info({ central: join45.central, cellId: join45.cellId }, "otium: worker mode enabled");
+  mountedScopes.set(join45.cellId, cachedSurfaceScope(join45));
   refreshDefaultSurfaceScope();
-  selfPeerNodeForCell(join44.cellId).then((self) => {
+  selfPeerNodeForCell(join45.cellId).then((self) => {
     if (self) {
       logger.info({ nodeName: self.nodeName, baseUrl: self.baseUrl }, "otium: attached to workspace");
     }
   }).catch((err2) => {
     logger.warn({ err: err2 }, "otium: self check against central failed (will retry per request)");
   });
-  resolveSurfaceScope(join44).then((scope) => {
+  resolveSurfaceScope(join45).then((scope) => {
     if (!scope || stopped)
       return;
-    mountedScopes.set(join44.cellId, scope);
+    mountedScopes.set(join45.cellId, scope);
     refreshDefaultSurfaceScope();
     if (mountedScopes.size === 1)
       stampUnscopedOtiumTopics(scope);
@@ -45913,14 +45727,14 @@ function startOtiumNodeRuntime(options) {
   });
   return {
     name: "otium",
-    join: join44,
+    join: join45,
     stop: () => {
       if (stopped)
         return;
       stopped = true;
-      mountedScopes.delete(join44.cellId);
+      mountedScopes.delete(join45.cellId);
       refreshDefaultSurfaceScope();
-      detachOtiumCentralCell(join44.cellId);
+      detachOtiumCentralCell(join45.cellId);
       releaseGlobals();
     }
   };
@@ -46015,14 +45829,14 @@ __export(exports_node_runtime, {
 function sameCredentials(left, right) {
   return left.central === right.central && left.relay === right.relay && left.secret === right.secret;
 }
-function attachOtiumWorkspace(join44) {
-  const current3 = mounted.get(join44.cellId);
+function attachOtiumWorkspace(join45) {
+  const current3 = mounted.get(join45.cellId);
   if (current3) {
-    if (sameCredentials(current3.join, join44))
+    if (sameCredentials(current3.join, join45))
       return false;
-    detachOtiumWorkspace(join44.cellId);
+    detachOtiumWorkspace(join45.cellId);
   }
-  mounted.set(join44.cellId, startOtiumNodeRuntime({ join: join44 }));
+  mounted.set(join45.cellId, startOtiumNodeRuntime({ join: join45 }));
   return true;
 }
 function detachOtiumWorkspace(cellId) {
@@ -46037,7 +45851,7 @@ function mountedOtiumWorkspaces() {
   return [...mounted.values()].map((runtime2) => runtime2.join);
 }
 function reconcileOtiumWorkspaces(joins = loadJoins()) {
-  const wanted = new Map(joins.map((join44) => [join44.cellId, join44]));
+  const wanted = new Map(joins.map((join45) => [join45.cellId, join45]));
   const detached = [];
   for (const cellId of [...mounted.keys()]) {
     if (wanted.has(cellId))
@@ -46046,8 +45860,8 @@ function reconcileOtiumWorkspaces(joins = loadJoins()) {
     detached.push(cellId);
   }
   const attached = [];
-  for (const [cellId, join44] of wanted) {
-    if (attachOtiumWorkspace(join44))
+  for (const [cellId, join45] of wanted) {
+    if (attachOtiumWorkspace(join45))
       attached.push(cellId);
   }
   if (attached.length > 0 || detached.length > 0) {
@@ -46070,9 +45884,9 @@ async function handleOtiumAdapterControlRequest(req) {
     if (req.method === "GET") {
       return Response.json({
         ok: true,
-        workspaces: mountedOtiumWorkspaces().map((join44) => ({
-          cellId: join44.cellId,
-          central: join44.central
+        workspaces: mountedOtiumWorkspaces().map((join45) => ({
+          cellId: join45.cellId,
+          central: join45.central
         }))
       });
     }
@@ -46093,8 +45907,8 @@ function mountConfiguredOtiumNodeRuntime() {
   const joins = loadJoins();
   if (joins.length === 0)
     return null;
-  for (const join44 of joins)
-    attachOtiumWorkspace(join44);
+  for (const join45 of joins)
+    attachOtiumWorkspace(join45);
   registerNodeRequestHandler("otium-adapter-control", handleOtiumAdapterControlRequest);
   let stopped = false;
   return {
@@ -46206,11 +46020,11 @@ async function joinCommand(args) {
     process.exitCode = 1;
     return;
   }
-  let join44;
+  let join45;
   let productionEnrollment = false;
   if (args.includes("--legacy")) {
     try {
-      join44 = parseInviteCode(code);
+      join45 = parseInviteCode(code);
     } catch (err2) {
       console.error(`invalid legacy invite code: ${err2 instanceof Error ? err2.message : err2}`);
       process.exitCode = 1;
@@ -46236,7 +46050,7 @@ async function joinCommand(args) {
           return;
         }
       }
-      join44 = await claimEnrollment(invite, nodeName);
+      join45 = await claimEnrollment(invite, nodeName);
       productionEnrollment = true;
     } catch (err2) {
       console.error(`enrollment failed: ${err2 instanceof Error ? err2.message : err2}`);
@@ -46247,16 +46061,16 @@ async function joinCommand(args) {
   let path;
   try {
     const saveOptions = { replaceExisting: args.includes("--replace") };
-    path = productionEnrollment ? commitEnrollment(join44, saveOptions) : saveJoin(join44, saveOptions);
+    path = productionEnrollment ? commitEnrollment(join45, saveOptions) : saveJoin(join45, saveOptions);
   } catch (err2) {
     console.error(`could not save join credentials: ${err2 instanceof Error ? err2.message : err2}`);
     process.exitCode = 1;
     return;
   }
   console.log(`otium join credentials saved to ${path}`);
-  console.log(`  central: ${join44.central}`);
-  console.log(`  cellId:  ${join44.cellId}`);
-  configureOtiumCentral(join44);
+  console.log(`  central: ${join45.central}`);
+  console.log(`  cellId:  ${join45.cellId}`);
+  configureOtiumCentral(join45);
   try {
     const self = await selfPeerNode();
     if (self) {
@@ -46284,6 +46098,50 @@ var init_join_cli = __esm(async () => {
   await init_join();
 });
 
+// ../../adapters/otium/src/status-cli.ts
+var exports_status_cli = {};
+__export(exports_status_cli, {
+  statusCommand: () => statusCommand
+});
+async function statusCommand() {
+  try {
+    const joins = loadJoins();
+    if (joins.length === 0) {
+      console.log("not joined to any Otium workspace");
+      process.exitCode = 1;
+      return;
+    }
+    configureOtiumCentral(joins[0] ?? null);
+    for (const join45 of joins.slice(1))
+      attachOtiumCentralCell(join45);
+    for (const [index, join45] of joins.entries()) {
+      if (index > 0)
+        console.log("");
+      console.log(`cellId:  ${join45.cellId}`);
+      console.log(`central: ${join45.central}`);
+      if (join45.relay)
+        console.log(`relay:   ${join45.relay}`);
+      try {
+        const self = await selfPeerNodeForCell(join45.cellId);
+        if (self) {
+          console.log(`node:    ${self.nodeName ?? join45.cellId}${self.isPrimary ? " (primary)" : ""}`);
+          console.log(`baseUrl: ${self.baseUrl}`);
+        } else {
+          console.warn("  warning: central answered but this cell has no visible assignment yet \u2014 check the workspace assignment");
+        }
+      } catch (err2) {
+        console.warn(`  warning: could not verify against central (${err2 instanceof Error ? err2.message : err2}) \u2014 showing locally known info only`);
+      }
+    }
+  } finally {
+    configureOtiumCentral(null);
+  }
+}
+var init_status_cli = __esm(async () => {
+  await init_central();
+  await init_join();
+});
+
 // ../../adapters/otium/src/sidecar.ts
 var exports_sidecar = {};
 __export(exports_sidecar, {
@@ -46302,13 +46160,13 @@ function resolveTunnelTargets(joins, relayOverride) {
   const targets = [];
   const skippedNoRelay = [];
   const envRelay = process.env.OTIUM_RELAY_URL?.trim();
-  for (const join44 of joins) {
-    const relayUrl = relayOverride?.trim() || join44.relay || envRelay;
+  for (const join45 of joins) {
+    const relayUrl = relayOverride?.trim() || join45.relay || envRelay;
     if (!relayUrl) {
-      skippedNoRelay.push(join44.cellId);
+      skippedNoRelay.push(join45.cellId);
       continue;
     }
-    targets.push({ cellId: join44.cellId, relayUrl, secret: join44.secret });
+    targets.push({ cellId: join45.cellId, relayUrl, secret: join45.secret });
   }
   return { targets, skippedNoRelay };
 }
@@ -46395,8 +46253,8 @@ async function runOtiumSidecar(options) {
   for (const tunnel of tunnels.values())
     tunnel.start();
   let resolveCompleted;
-  const completed = new Promise((resolve27) => {
-    resolveCompleted = resolve27;
+  const completed = new Promise((resolve28) => {
+    resolveCompleted = resolve28;
   });
   onShutdown("otium-sidecar-server", 130, () => server?.stop(true));
   onShutdown("otium-sidecar-tunnel", 120, () => {
@@ -46524,6 +46382,14 @@ async function runOtiumCli(args = process.argv.slice(2)) {
       await joinCommand2(commandArgs);
       break;
     }
+    case "status": {
+      if (commandArgs.length > 0) {
+        throw new Error("usage: negotium otium status");
+      }
+      const { statusCommand: statusCommand2 } = await init_status_cli().then(() => exports_status_cli);
+      await statusCommand2();
+      break;
+    }
     case "leave": {
       const targetCellId = commandArgs[0]?.trim();
       if (commandArgs.length > 1 || targetCellId?.startsWith("-")) {
@@ -46537,9 +46403,9 @@ async function runOtiumCli(args = process.argv.slice(2)) {
       if (joins.length === 0)
         throw new Error("not joined to an Otium workspace");
       if (!targetCellId && joins.length > 1) {
-        throw new Error(`this node is joined to ${joins.length} workspaces; name one to leave: ${joins.map((join44) => join44.cellId).join(", ")}`);
+        throw new Error(`this node is joined to ${joins.length} workspaces; name one to leave: ${joins.map((join45) => join45.cellId).join(", ")}`);
       }
-      if (targetCellId && !joins.some((join44) => join44.cellId === targetCellId)) {
+      if (targetCellId && !joins.some((join45) => join45.cellId === targetCellId)) {
         throw new Error(`not joined as ${targetCellId}`);
       }
       removeJoin2(targetCellId);
@@ -46562,10 +46428,11 @@ async function runOtiumCli(args = process.argv.slice(2)) {
       console.log([
         "negotium otium \u2014 attach a Negotium node to an Otium workspace",
         "",
-        "usage: negotium otium <join|leave|serve> [args]",
+        "usage: negotium otium <join|leave|status|serve> [args]",
         "",
         "  join <code>   store credentials from an Otium invite code",
         "  leave         remove the stored workspace credentials",
+        "  status        show which workspace(s)/central this node is joined to",
         "  serve [--port <port>] [--relay <url>]",
         "                 run peer routes and an outbound relay tunnel",
         "",
@@ -47126,7 +46993,7 @@ var CLI_COMMANDS = [
   },
   {
     name: "otium",
-    usage: "otium join|leave|serve",
+    usage: "otium join|leave|status|serve",
     description: "manage the Otium workspace connection",
     group: "Channels"
   }
@@ -47191,7 +47058,7 @@ async function runCanonicalNode(port) {
   });
   console.log(`negotium node listening on 127.0.0.1:${node.port} (ctrl-c to stop)`);
   await node.completed;
-  await new Promise((resolve27) => setImmediate(resolve27));
+  await new Promise((resolve28) => setImmediate(resolve28));
   process.exit(0);
 }
 async function stopAdapter(name) {
@@ -47325,4 +47192,4 @@ switch (command) {
   }
 }
 
-//# debugId=28B32B58D5A6FD9664756E2164756E21
+//# debugId=8E2AD65C6830FCEF64756E2164756E21