@wrongstack/core 0.305.0 → 0.306.0

package/dist/session-catalog/project-server.js

@@ -2,10 +2,10 @@
 
 // src/session-catalog/project-server.ts
 import { randomBytes as randomBytes2, randomUUID as randomUUID2 } from "node:crypto";
-import * as fs3 from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as net from "node:net";
 import * as path3 from "node:path";
+import { bindProjectEndpoint } from "@wrongstack/persistence";
 
 // src/security/file-permissions.ts
 import { chmod } from "node:fs/promises";
@@ -177,17 +177,9 @@ function useDaemonPerfDefaults() {
 
 // src/session-catalog/endpoint.ts
 import { createHash } from "node:crypto";
-import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-// src/utils/socket-path.ts
-import {
-  assertUnixSocketPathWithinLimit,
-  checkUnixSocketPath,
-  unixSocketPathLimit
-} from "@wrongstack/persistence";
-
 // src/session-catalog/protocol.ts
 var SESSION_CATALOG_PROTOCOL_VERSION = 1;
 var SESSION_CATALOG_MAX_FRAME_CHARS = 4 * 1024 * 1024;
@@ -218,15 +210,10 @@ function sessionCatalogProjectServerEndpoint(projectDir) {
 function sessionCatalogProjectServerMetadataPath(projectDir) {
   return path.join(projectDir, SESSION_CATALOG_METADATA_FILE);
 }
-function ensureSessionCatalogSocketDirectory(endpoint2) {
-  if (process.platform === "win32") return;
-  assertUnixSocketPathWithinLimit(endpoint2, "session-catalog");
-  fs.mkdirSync(path.dirname(endpoint2), { recursive: true, mode: 448 });
-}
 
 // src/session-catalog/store.ts
 import { createHash as createHash2, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 import * as path2 from "node:path";
 
 // src/coordination/sqlite-mailbox-schema.ts
@@ -632,7 +619,7 @@ var SessionCatalogStore = class {
   constructor(projectDir) {
     this.projectDir = projectDir;
     this.sessionsDir = path2.join(projectDir, "sessions");
-    fs2.mkdirSync(this.sessionsDir, { recursive: true, mode: 448 });
+    fs.mkdirSync(this.sessionsDir, { recursive: true, mode: 448 });
     this.databasePath = path2.join(this.sessionsDir, "catalog.sqlite");
     const Database = loadDatabaseSync();
     this.db = new Database(this.databasePath);
@@ -650,12 +637,12 @@ var SessionCatalogStore = class {
       this.db.close();
       const quarantine = `${this.databasePath}.corrupt-${Date.now()}`;
       try {
-        fs2.renameSync(this.databasePath, quarantine);
+        fs.renameSync(this.databasePath, quarantine);
       } catch {
       }
       for (const suffix of ["-wal", "-shm"]) {
         try {
-          fs2.renameSync(`${this.databasePath}${suffix}`, `${quarantine}${suffix}`);
+          fs.renameSync(`${this.databasePath}${suffix}`, `${quarantine}${suffix}`);
         } catch {
         }
       }
@@ -881,7 +868,7 @@ var SessionCatalogStore = class {
       if (this.maintenanceExists(targetSessionId))
         throw conflict(`Session ${targetSessionId} is under maintenance`);
       const catalog = this.db.prepare("SELECT 1 AS yes FROM sessions WHERE session_id=?").get(targetSessionId);
-      if (!catalog && !fs2.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
+      if (!catalog && !fs.existsSync(this.containedPath(`${targetSessionId}.jsonl`)))
         throw new Error(`Session not found: ${targetSessionId}`);
       const reservationId = randomUUID();
       const now = Date.now();
@@ -1027,7 +1014,7 @@ var SessionCatalogStore = class {
     transcriptRelativePath = normalizedTranscript;
     summaryRelativePath = normalizedSummary;
     const transcript = this.containedPath(transcriptRelativePath);
-    const stat = fs2.existsSync(transcript) ? fs2.statSync(transcript) : void 0;
+    const stat = fs.existsSync(transcript) ? fs.statSync(transcript) : void 0;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     return this.transaction(() => {
       const prior = this.db.prepare("SELECT summary_revision FROM sessions WHERE session_id=?").get(summary.id);
@@ -1150,7 +1137,7 @@ var SessionCatalogStore = class {
     if (trimmed) summary.name = this.scrubber.scrub(trimmed).slice(0, 500);
     else delete summary.name;
     const summaryPath = this.containedPath(current.summaryRelativePath);
-    fs2.mkdirSync(path2.dirname(summaryPath), { recursive: true, mode: 448 });
+    fs.mkdirSync(path2.dirname(summaryPath), { recursive: true, mode: 448 });
     await atomicWrite(summaryPath, `${JSON.stringify(summary)}
 `, { mode: 384 });
     try {
@@ -1213,13 +1200,13 @@ var SessionCatalogStore = class {
       path2.join(path2.dirname(transcript), path2.basename(sessionId))
     ];
     const trashRoot = path2.join(this.sessionsDir, "_trash", lease.leaseId);
-    fs2.mkdirSync(trashRoot, { recursive: true, mode: 448 });
+    fs.mkdirSync(trashRoot, { recursive: true, mode: 448 });
     const moved = [];
     try {
       artifacts.forEach((artifact, index) => {
-        if (!fs2.existsSync(artifact)) return;
+        if (!fs.existsSync(artifact)) return;
         const target = path2.join(trashRoot, `${index}-${path2.basename(artifact)}`);
-        fs2.renameSync(artifact, target);
+        fs.renameSync(artifact, target);
         moved.push({ from: artifact, to: target });
       });
       this.transaction(() => {
@@ -1234,17 +1221,17 @@ var SessionCatalogStore = class {
     } catch (error) {
       for (const item of moved.reverse()) {
         try {
-          fs2.mkdirSync(path2.dirname(item.from), { recursive: true, mode: 448 });
-          fs2.renameSync(item.to, item.from);
+          fs.mkdirSync(path2.dirname(item.from), { recursive: true, mode: 448 });
+          fs.renameSync(item.to, item.from);
         } catch {
         }
       }
       throw error;
     }
     try {
-      fs2.rmSync(trashRoot, { recursive: true, force: true });
+      fs.rmSync(trashRoot, { recursive: true, force: true });
       const trashParent = path2.dirname(trashRoot);
-      if (fs2.readdirSync(trashParent).length === 0) fs2.rmdirSync(trashParent);
+      if (fs.readdirSync(trashParent).length === 0) fs.rmdirSync(trashParent);
     } catch {
     }
   }
@@ -1281,10 +1268,10 @@ var SessionCatalogStore = class {
       for (const id of ids) {
         try {
           const summaryFile = this.containedPath(`${id}.summary.json`);
-          const summary = fs2.existsSync(summaryFile) ? parseJson(fs2.readFileSync(summaryFile, "utf8")) : this.summarizeTranscript(id);
+          const summary = fs.existsSync(summaryFile) ? parseJson(fs.readFileSync(summaryFile, "utf8")) : this.summarizeTranscript(id);
           if (!summary || summary.id !== id) throw new Error("summary identity mismatch");
           const transcript = this.containedPath(`${id}.jsonl`);
-          const stat = fs2.existsSync(transcript) ? fs2.statSync(transcript) : void 0;
+          const stat = fs.existsSync(transcript) ? fs.statSync(transcript) : void 0;
           const now = (/* @__PURE__ */ new Date()).toISOString();
           this.db.prepare(
             "INSERT INTO sessions(session_id,transcript_relative_path,summary_relative_path,summary_json,transcript_size,transcript_mtime_ms,summary_revision,indexed_at,damaged) VALUES (?,?,?,?,?,?,?,?,0)"
@@ -1325,7 +1312,7 @@ var SessionCatalogStore = class {
   walkFiles(root, suffix) {
     const result = [];
     const visit = (dir) => {
-      for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           if (entry.name !== "_cas" && entry.name !== "_trash") visit(path2.join(dir, entry.name));
         } else if (entry.isFile() && entry.name.endsWith(suffix))
@@ -1337,7 +1324,7 @@ var SessionCatalogStore = class {
   }
   summarizeTranscript(id) {
     const file = this.containedPath(`${id}.jsonl`);
-    const lines = fs2.readFileSync(file, "utf8").split(/\r?\n/);
+    const lines = fs.readFileSync(file, "utf8").split(/\r?\n/);
     let start;
     let endedAt;
     let lastActivityAt;
@@ -1846,7 +1833,6 @@ async function stop(_reason) {
   if (process.platform !== "win32") await fsp.rm(endpoint, { force: true }).catch(() => void 0);
   await removeOwnedMetadata();
 }
-ensureSessionCatalogSocketDirectory(endpoint);
 var server = net.createServer((socket) => {
   if (stopping) {
     socket.destroy();
@@ -1870,42 +1856,28 @@ var server = net.createServer((socket) => {
     scheduleIdleStop(disconnectedIdleMs);
   });
 });
-var probing = false;
-function listen() {
-  server.listen(endpoint);
-}
-server.on("error", (error) => {
-  if (error.code === "EADDRINUSE" && process.platform === "win32") {
+void (async () => {
+  const bind = await bindProjectEndpoint({ server, endpoint, service: "session-catalog" });
+  if (bind.outcome === "already-owned") {
     process.exitCode = 0;
     return;
   }
-  if (error.code === "EADDRINUSE" && !probing) {
-    probing = true;
-    const probe = net.createConnection(endpoint);
-    probe.once("connect", () => {
-      probe.destroy();
-      process.exitCode = 0;
-    });
-    probe.once("error", () => {
-      probe.destroy();
-      try {
-        fs3.rmSync(endpoint, { force: true });
-      } catch {
-      }
-      probing = false;
-      listen();
-    });
+  if (bind.outcome === "failed") {
+    process.stderr.write(`session-catalog project server failed: ${bind.error.message}
+`);
+    process.exitCode = 1;
     return;
   }
-  process.exitCode = 1;
-});
-server.on("listening", () => {
-  if (process.platform !== "win32") {
-    try {
-      fs3.chmodSync(endpoint, 384);
-    } catch {
-    }
+  if (bind.reclaimedStaleEndpoint) {
+    process.stderr.write(`session-catalog project server reclaimed stale endpoint ${endpoint}
+`);
   }
+  server.on("error", (error) => {
+    if (stopping) return;
+    process.stderr.write(`session-catalog project server error: ${error.message}
+`);
+    process.exitCode = 1;
+  });
   try {
     store = new SessionCatalogStore(parsed.projectDir);
     void writeMetadata().then(() => metadataReadyResolve?.()).catch(() => void stop("metadata write failed"));
@@ -1914,8 +1886,7 @@ server.on("listening", () => {
     return;
   }
   scheduleIdleStop();
-});
+})();
 process.once("SIGINT", () => void stop("SIGINT"));
 process.once("SIGTERM", () => void stop("SIGTERM"));
-listen();
 //# sourceMappingURL=project-server.js.map

package/dist/tools/fallback-manage-tool-options.d.ts

@@ -10,6 +10,15 @@ export interface FallbackManageToolOptions {
     updateConfig: (mutate: (cfg: Record<string, unknown>) => void) => Promise<void>;
     /** Optional secure interactive input callback for secrets such as API keys. */
     requestInput?: ((prompt: string) => Promise<string>) | undefined;
+    /**
+     * Optional live provider/model switch (the host's switchProviderAndModel).
+     * When present, `leader_model_set` routes leader changes through it so the
+     * live agent context (provider instance, model, context caps) follows the
+     * config write. Returns an error string on failure, null on success —
+     * mirroring cli-main's switch callback. When absent, the tool persists the
+     * config and reports that the live session keeps its current model.
+     */
+    switchProviderAndModel?: ((providerId: string, modelId: string) => Promise<string | null>) | undefined;
     /** Optional logger for internal warnings. */
     logger?: Logger | undefined;
 }

package/dist/tools/index.js

@@ -3908,6 +3908,7 @@ var TOOLS = {
     "glob",
     "search",
     "tree",
+    "diff",
     "write",
     "edit",
     "replace",
@@ -4939,7 +4940,7 @@ var VERIFY_AGENTS = [
       id: "e2e",
       name: "E2E",
       role: "e2e",
-      tools: [...TOOLS.build, "fetch", ...SPECIALIST_TOOLS.browser],
+      tools: [...TOOLS.build, "fetch", "e2e_plan", ...SPECIALIST_TOOLS.browser],
       prompt: agentPrompt("e2e")
     },
     budget: HEAVY_BUDGET,
@@ -5452,7 +5453,7 @@ var DOMAIN_AGENTS = [
       id: "designer",
       name: "Designer",
       role: "designer",
-      tools: [...TOOLS.docs],
+      tools: [...TOOLS.docs, "design"],
       prompt: agentPrompt("designer")
     },
     budget: MEDIUM_BUDGET,
@@ -6661,7 +6662,7 @@ function createFallbackChainManageTool(opts) {
     name: FALLBACK_CHAIN_MANAGE_TOOL_NAME,
     description: "View or change the active rate-limit fallback chain. When the primary model is overloaded (429/5xx), the agent rotates through this chain in order. Every new entry must be a FAVORITE model \u2014 add it via favorite_manage first. Use insert to place a fallback at a specific position; use remove to delete an entry.",
     usageHint: '"list" to see the current chain. "add" with a favorite model to append. "insert" with an index (1-based) to place before that position. "remove" with index or model ref. "clear" to empty the chain (auto fallback takes over).',
-    category: "Config",
+    category: "config",
     inputSchema: FALLBACK_CHAIN_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -6811,7 +6812,7 @@ function createFavoriteManageTool(opts) {
     name: FAVORITE_MANAGE_TOOL_NAME,
     description: "Manage your favorite provider/model list. Favorites are the only models that can be added to fallback chains and profiles. The LLM uses this tool to curate which models are available for fallback and role assignment.",
     usageHint: 'Start with "list" to see current favorites. Use "add <provider/model>" to add. Use "remove <index|ref>" to remove.',
-    category: "Config",
+    category: "config",
     inputSchema: FAVORITE_MANAGE_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -6891,7 +6892,7 @@ async function storeProviderKey(providers, input, keyValue, opts) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   entry.apiKeys = existingKeys;
-  entry.apiKey = void 0;
+  delete entry.apiKey;
   if (input.setActive !== false) {
     entry.activeKey = label;
   }
@@ -6934,7 +6935,7 @@ function createSystemConfigViewTool(opts) {
     name: SYSTEM_CONFIG_VIEW_TOOL_NAME,
     description: "Get a comprehensive view of all provider, model, fallback, and matrix configuration. Shows the complete state across all configurable areas so you can see what is available and make informed decisions when assigning models, creating fallback profiles, or managing providers. Use the section parameter to focus on specific areas.",
     usageHint: '"section: all" for everything. "section: providers" for configured providers and key status. "section: models" for leader model and favorites. "section: fallbacks" for chains, profiles, and toggles. "section: matrix" for per-role assignments. "section: refiner" for goal refinement config.',
-    category: "Config",
+    category: "config",
     inputSchema: SYSTEM_CONFIG_VIEW_SCHEMA,
     permission: "auto",
     mutating: false,
@@ -7238,7 +7239,7 @@ function createFallbackProfileManageTool(opts) {
     name: FALLBACK_PROFILE_MANAGE_TOOL_NAME,
     description: "Manage named fallback profiles. A profile is a reusable, ordered list of model references that can be assigned to agent roles. Every entry in a profile must be a FAVORITE model \u2014 add it via favorite_manage first. Use /setmodel or agent_model_assign to assign a profile to a role.",
     usageHint: '"list" to see all profiles. "set" with name and chain (array of model refs) to create or replace a profile. "delete" with name to remove a profile.',
-    category: "Config",
+    category: "config",
     inputSchema: FALLBACK_PROFILE_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -7349,7 +7350,7 @@ function createAgentModelAssignTool(opts) {
     name: AGENT_MODEL_ASSIGN_TOOL_NAME,
     description: "Assign a provider/model or a fallback profile to a specific agent role, phase, or the fleet-wide default. This is the LLM-accessible equivalent of /setmodel set. The provider+model combination must be in your favorites list (unless only clearing). Resolution precedence: exact role \u2192 phase \u2192 * \u2192 leader model.",
     usageHint: 'Use "list" as role to see current assignments. Set with role + model, or role + provider + model, or role + profile. Set role + clear=true to remove a matrix entry. The provider/model must be a favorite.',
-    category: "Config",
+    category: "config",
     inputSchema: AGENT_MODEL_ASSIGN_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -7497,7 +7498,7 @@ function createProviderManageTool(opts) {
     name: PROVIDER_MANAGE_TOOL_NAME,
     description: "View or configure provider entries. List all configured providers with their type, model lists, base URL, and key status. Add new providers, update their settings, or remove unused ones. API keys should be set via provider_key_set instead of passing them here \u2014 they are visible in the LLM output.",
     usageHint: '"list" to see all providers. "add" with provider id and type to create. "configure" to update models, baseUrl, family, or envVars. "remove" to delete a provider. Use provider_key_set for API key management.',
-    category: "Config",
+    category: "config",
     inputSchema: PROVIDER_MANAGE_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -7646,9 +7647,11 @@ function createProviderKeySetTool(opts) {
     name: PROVIDER_KEY_SET_TOOL_NAME,
     description: "Set the API key for a provider. For security, prefer using envVar (reads from environment variable, value never visible to the LLM) over passing the key directly. When neither key nor envVar is provided, the tool returns a prompt for interactive key entry \u2014 the UI will present an input field and the key is stored without LLM visibility.\n\nAfter setting a key, the provider becomes usable for model assignments and fallback chains. Add its models to favorites with favorite_manage to unlock them for fallback/profile use.",
     usageHint: 'Preferred: provider_key_set({ provider: "openai", envVar: "OPENAI_API_KEY" }). For interactive input: provider_key_set({ provider: "openai" }) \u2014 the UI will prompt. Direct key: provider_key_set({ provider: "openai", key: "sk-..." }) \u2014 visible to LLM.',
-    category: "Config",
+    category: "config",
     inputSchema: PROVIDER_KEY_SET_SCHEMA,
-    permission: "auto",
+    // 'confirm', not 'auto' — this tool writes credentials to disk (and can
+    // read arbitrary env vars into the config file), so the user must see it.
+    permission: "confirm",
     mutating: true,
     riskTier: "standard",
     icon: "settings",
@@ -7744,7 +7747,7 @@ function createLeaderModelSetTool(opts) {
     name: LEADER_MODEL_SET_TOOL_NAME,
     description: 'View or change the leader provider/model and system toggles. The leader is the primary model used for the main agent interactions. "set" changes it directly. "profile" derives it from a named fallback profile (first entry becomes leader, rest become the fallback chain). "toggle" controls fallbackAuto (smart default fallback) and favoriteModelsOnly (restrict auto-fallback to favorites only).',
     usageHint: '"show" to see current state. "set" with provider+model to change. "profile" with name to derive from a profile. "toggle" with toggle name and value to change a boolean setting.',
-    category: "Config",
+    category: "config",
     inputSchema: LEADER_MODEL_SET_SCHEMA,
     permission: "auto",
     mutating: true,
@@ -7768,11 +7771,21 @@ function createLeaderModelSetTool(opts) {
         if (!input.provider || !input.model) {
           return { status: "error", message: 'Provide "provider" and "model" for the leader.' };
         }
+        if (opts.switchProviderAndModel) {
+          const switchError = await opts.switchProviderAndModel(input.provider, input.model);
+          if (switchError) {
+            return {
+              status: "error",
+              message: `Could not switch to ${input.provider}/${input.model}: ${switchError}. Config was not changed.`
+            };
+          }
+        }
         await opts.updateConfig((cfg) => {
           cfg.provider = input.provider;
           cfg.model = input.model;
         });
-        return { status: "ok", message: `\u2713 Leader \u2192 ${input.provider}/${input.model}` };
+        const liveNote = opts.switchProviderAndModel ? "" : " (config updated \u2014 the live session keeps its current model until restart or /setmodel)";
+        return { status: "ok", message: `\u2713 Leader \u2192 ${input.provider}/${input.model}${liveNote}` };
       }
       if (input.action === "profile") {
         if (!input.profile) {
@@ -7791,15 +7804,25 @@ function createLeaderModelSetTool(opts) {
           return { status: "error", message: `Cannot parse "${first}" as a valid model reference.` };
         }
         const rest = chain.slice(1);
+        if (opts.switchProviderAndModel) {
+          const switchError = await opts.switchProviderAndModel(provider, model);
+          if (switchError) {
+            return {
+              status: "error",
+              message: `Could not switch to ${provider}/${model}: ${switchError}. Config was not changed.`
+            };
+          }
+        }
         await opts.updateConfig((cfg) => {
           cfg.provider = provider;
           cfg.model = model;
           cfg.fallbackModels = rest;
         });
+        const profileLiveNote = opts.switchProviderAndModel ? "" : "\n  (config updated \u2014 the live session keeps its current model until restart or /setmodel)";
         return {
           status: "ok",
           message: `\u2713 Leader \u2192 ${provider}/${model} (profile: ${input.profile})` + (rest.length > 0 ? `
-  Fallback chain: ${rest.join(" \u2192 ")}` : "")
+  Fallback chain: ${rest.join(" \u2192 ")}` : "") + profileLiveNote
         };
       }
       if (input.action === "toggle") {
@@ -8283,20 +8306,22 @@ async function runEnable(name, deps) {
     const known = Object.keys(all).join(", ");
     return `Unknown server "${name}". Available presets: ${known}`;
   }
-  await updateJsonObjectFile(deps.configPath, (full) => {
+  const persistEnabled = () => updateJsonObjectFile(deps.configPath, (full) => {
     const current = isMcpServerRecord(full.mcpServers) ? full.mcpServers : {};
     setJsonPath(full, ["mcpServers", name], { ...current[name], ...cfg, enabled: true });
   });
   try {
     const live = deps.registry.describe().find((s) => s.name === name);
     if (live && live.state === "connected") {
-      return `${green("\u25CF")} Server "${name}" is already running (${live.toolCount} tools registered).`;
+      await persistEnabled();
+      return `Server "${name}" is already running (${live.toolCount} tools registered).`;
     }
     await deps.registry.start({ ...cfg, enabled: true });
+    await persistEnabled();
     const updated = deps.registry.describe().find((s) => s.name === name);
-    return `${green("\u2713 Enabled and started")} "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
+    return `Enabled and started "${name}"${updated ? ` (${updated.toolCount} tools registered).` : "."}`;
   } catch (err) {
-    return `${red("\u2717 Failed to start")} "${name}": ${toErrorMessage(err)}`;
+    return `Failed to start "${name}": ${toErrorMessage(err)}. Config was left unchanged (server stays disabled).`;
   }
 }
 async function runDisable(name, deps) {
@@ -8370,34 +8395,34 @@ function isMcpServerRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function bold(s) {
-  return `\x1B[1m${s}\x1B[0m`;
+  return s;
 }
 function dim(s) {
-  return `\x1B[2m${s}\x1B[0m`;
+  return s;
 }
 function green(s) {
-  return `\x1B[32m${s}\x1B[0m`;
+  return s;
 }
 function yellow(s) {
-  return `\x1B[33m${s}\x1B[0m`;
+  return s;
 }
 function red(s) {
-  return `\x1B[31m${s}\x1B[0m`;
+  return s;
 }
 function badge(state) {
   switch (state) {
     case "connected":
-      return green("\u25CF connected");
+      return "\u25CF connected";
     case "connecting":
-      return `\x1B[36m\u25D0 connecting\x1B[0m`;
+      return "\u25D0 connecting";
     case "reconnecting":
-      return `\x1B[36m\u25D1 reconnecting\x1B[0m`;
+      return "\u25D1 reconnecting";
     case "disconnected":
-      return dim("\u25CB disconnected");
+      return "\u25CB disconnected";
     case "failed":
-      return red("\u2717 failed");
+      return "\u2717 failed";
     default:
-      return dim(state);
+      return state;
   }
 }
 
@@ -8462,13 +8487,19 @@ function createMcpUseTool(opts) {
       const servers = registry.describe();
       const serverInfo = servers.find((s) => s.name === serverName);
       if (!serverInfo) {
-        return `Server "${serverName}" not found. Available: ${servers.map((s) => s.name).join(", ") || "none"}.`;
+        throw new Error(
+          `Server "${serverName}" not found. Available: ${servers.map((s) => s.name).join(", ") || "none"}.`
+        );
       }
       if (serverInfo.state !== "connected") {
-        return `Server "${serverName}" is not connected (state: ${serverInfo.state}). Use \`mcp_control({ action: "enable", server: "${serverName}" })\` first.`;
+        throw new Error(
+          `Server "${serverName}" is not connected (state: ${serverInfo.state}). Use \`mcp_control({ action: "enable", server: "${serverName}" })\` first.`
+        );
       }
-      if (registry.activateServer) {
-        registry.activateServer(serverName);
+      const alreadyActive = registry.isActivated?.(serverName) === true;
+      const didActivate = !alreadyActive && Boolean(registry.activateServer);
+      if (didActivate) {
+        registry.activateServer?.(serverName);
       }
       try {
         const qualifiedName = mcpQualifiedToolName(serverName, toolName);
@@ -8476,7 +8507,7 @@ function createMcpUseTool(opts) {
         if (!mcpTool) {
           const allTools = toolRegistry.list().filter((t) => t.name.startsWith(mcpServerToolPrefix(serverName))).map((t) => t.name.replace(mcpServerToolPrefix(serverName), ""));
           const hint = allTools.length > 0 ? `Available tools on "${serverName}": ${allTools.join(", ")}.` : `No tools found on "${serverName}". The server may not have published any tools.`;
-          return `Tool "${toolName}" not found on server "${serverName}". ${hint}`;
+          throw new Error(`Tool "${toolName}" not found on server "${serverName}". ${hint}`);
         }
         const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
         if (typeof governedExecute !== "function") {
@@ -8486,7 +8517,7 @@ function createMcpUseTool(opts) {
         if (!result.success) throw new Error(result.error ?? "MCP tool execution failed");
         return result.result;
       } finally {
-        if (registry.deactivateServer) {
+        if (didActivate && registry.deactivateServer) {
           registry.deactivateServer(serverName);
         }
       }
@@ -8781,6 +8812,7 @@ function asTextBlocks(system) {
 
 // src/tools/one-shot-llm-tool.ts
 var ONE_SHOT_LLM_TOOL_NAME = "llm";
+var MAX_TIMEOUT_MS = 12e4;
 var INPUT_SCHEMA2 = {
   type: "object",
   properties: {
@@ -8857,9 +8889,10 @@ var INPUT_SCHEMA2 = {
     },
     timeoutMs: {
       type: "number",
-      description: "Hard timeout in ms (default 30s)."
+      description: `Hard timeout in ms (default 30s, clamped to a maximum of ${MAX_TIMEOUT_MS}).`
     }
-  }
+  },
+  additionalProperties: false
 };
 function createOneShotLLMTool(opts) {
   const orchestrator = new OneShotOrchestrator({
@@ -8867,6 +8900,7 @@ function createOneShotLLMTool(opts) {
     getConfig: opts.getConfig,
     fallbackProfileManager: opts.fallbackProfileManager,
     modelRouter: opts.modelRouter,
+    statusTracker: opts.statusTracker,
     logger: opts.logger,
     wrapProviderCall: opts.wrapProviderCall
   });
@@ -8875,8 +8909,23 @@ function createOneShotLLMTool(opts) {
     description: "Make a one-shot LLM call with a system prompt and user input. Supports provider selection, model routing by role, fallback chains, and timeout. Returns the response text, model info, token usage, and whether a fallback was used. Use this for summarization, classification, extraction, and any single-turn LLM task.",
     usageHint: "Provide `system` for the instruction and `userPrompt` for the input. Either set `model`+`providerId`, or have defaults configured on the tool. Set `fallbackModels` for resilience. Check `error` on the result for failure details.",
     inputSchema: INPUT_SCHEMA2,
+    // Metadata mirrors council-tool.ts — both are read-only meta tools that
+    // spend tokens but never touch the workspace.
+    category: "meta",
     permission: "auto",
     mutating: false,
+    riskTier: "safe",
+    maxOutputBytes: 262144,
+    validate(input) {
+      const hasPrompt = typeof input.userPrompt === "string" && input.userPrompt.trim().length > 0;
+      const hasMessages = Array.isArray(input.messages) && input.messages.length > 0;
+      if (!hasPrompt && !hasMessages) {
+        return [
+          "Provide `userPrompt` (a single user turn) or `messages` (a conversation array) \u2014 without either the llm tool has nothing to send to the model."
+        ];
+      }
+      return [];
+    },
     async execute(input, _ctx, { signal }) {
       if (!input.model && !input.providerId && !opts.defaultModel && !opts.defaultProvider) {
         return {
@@ -8893,7 +8942,11 @@ function createOneShotLLMTool(opts) {
         ...input,
         signal: input.signal ? AbortSignal.any([input.signal, signal]) : signal,
         model: input.model ?? opts.defaultModel,
-        providerId: input.providerId ?? opts.defaultProvider
+        providerId: input.providerId ?? opts.defaultProvider,
+        // Clamp runaway timeouts (documented on the schema). Non-positive
+        // values fall back to the orchestrator default rather than making the
+        // call instantly un-completable.
+        ...typeof input.timeoutMs === "number" && input.timeoutMs > 0 ? { timeoutMs: Math.min(input.timeoutMs, MAX_TIMEOUT_MS) } : { timeoutMs: void 0 }
       };
       return orchestrator.call(effectiveInput);
     }

package/dist/tools/one-shot-llm-tool.d.ts

@@ -17,6 +17,12 @@ export interface CreateOneShotLLMToolOptions {
     /** Shared live FallbackProfileManager — required. */
     fallbackProfileManager: OneShotOrchestratorOptions['fallbackProfileManager'];
     modelRouter?: OneShotOrchestratorOptions['modelRouter'];
+    /**
+     * Shared provider/model status tracker. Without it the orchestrator never
+     * records failures/successes for `llm` calls, so provider health stays
+     * blind to this tool's traffic and blocked entries are not skipped.
+     */
+    statusTracker?: OneShotOrchestratorOptions['statusTracker'];
     logger?: OneShotOrchestratorOptions['logger'];
     wrapProviderCall?: OneShotOrchestratorOptions['wrapProviderCall'];
     /**

package/dist/types/blocks.d.ts

@@ -36,6 +36,16 @@ export interface ToolResultBlock {
     name?: string | undefined;
     content: string;
     is_error?: boolean | undefined;
+    /**
+     * Provider cache boundary. Set at request-composition time on a CLONE of the
+     * trailing durable block (never on the stored message) so the conversation
+     * prefix becomes an incrementally extendable cache entry. Wires that use
+     * explicit markers (Anthropic) emit it; every other wire rebuilds
+     * tool_result content explicitly and drops it.
+     */
+    cache_control?: {
+        type: 'ephemeral' | undefined;
+    };
     /**
      * Structured tool error information. Present on error results produced
      * by the unified tool error taxonomy (tool-error-taxonomy.ts). Consumed

package/dist/types/config/ui.d.ts

@@ -5,10 +5,13 @@
  * the TUI runtime can all reference the same string union without
  * importing the TUI package (which would invert the dependency direction).
  *
- * Keep in lockstep with `THEME_OPTIONS` in `packages/tui/src/theme.ts`.
- * Adding a preset here is intentional — it also requires updating the TUI
- * presets map AND the CLI `VALID_PRESETS` set in `tui-theme-adapter.ts`.
+ * This array is the CANONICAL list. The CLI `/theme` command and the boot
+ * theme adapter both derive their valid-id sets from it, so adding an entry
+ * here needs exactly ONE follow-up: a matching palette + `THEME_OPTIONS` row
+ * in `packages/tui/src/theme.ts`. Both are compile-enforced — `themePresets`
+ * is typed `Record<ThemePresetId, Theme>` (no cast) and the CLI's `THEME_META`
+ * is a total record — so a missing preset fails `tsc`, not the runtime.
  */
-export declare const THEME_PRESET_IDS: readonly ['catppuccin', 'tokyo-night', 'nord', 'cyberpunk', 'dracula', 'gruvbox-dark', 'solarized-dark', 'one-dark', 'monokai', 'rose-pine', 'kanagawa', 'ayu-dark', 'everforest', 'night-owl', 'synthwave'];
+export declare const THEME_PRESET_IDS: readonly ['catppuccin', 'tokyo-night', 'nord', 'cyberpunk', 'dracula', 'gruvbox-dark', 'solarized-dark', 'one-dark', 'monokai', 'rose-pine', 'kanagawa', 'ayu-dark', 'everforest', 'night-owl', 'synthwave', 'github-dark', 'material-ocean', 'nightfox', 'oxocarbon', 'catppuccin-macchiato', 'catppuccin-frappe', 'gruvbox-material', 'tokyo-night-storm', 'rose-pine-moon', 'zenburn', 'palenight', 'horizon', 'sonokai', 'edge-dark', 'moonfly', 'melange', 'poimandres', 'vitesse-dark', 'aura', 'dark-plus'];
 export type ThemePresetId = (typeof THEME_PRESET_IDS)[number];
 //# sourceMappingURL=ui.d.ts.map