@wrongstack/webui 0.265.1 → 0.267.0

package/dist/server/entry.js

@@ -182,8 +182,8 @@ import {
   createAutonomyBrain,
   createTieredBrainArbiter
 } from "@wrongstack/core";
-import * as fs10 from "fs/promises";
-import * as path10 from "path";
+import * as fs9 from "fs/promises";
+import * as path9 from "path";
 
 // src/server/http-server.ts
 import * as fs from "fs/promises";
@@ -225,8 +225,8 @@ function extractTokenFromCookie(cookieHeader) {
   for (const part of raw.split(";")) {
     const eq = part.indexOf("=");
     if (eq < 0) continue;
-    const name = part.slice(0, eq).trim();
-    if (name === "ws_token") {
+    const name2 = part.slice(0, eq).trim();
+    if (name2 === "ws_token") {
       try {
         return decodeURIComponent(part.slice(eq + 1).trim());
       } catch {
@@ -931,8 +931,8 @@ var KEEP_DOTFILES = /* @__PURE__ */ new Set([
   ".eslintrc",
   ".prettierrc"
 ]);
-function isHiddenEntry(name) {
-  return name.startsWith(".") && !KEEP_DOTFILES.has(name);
+function isHiddenEntry(name2) {
+  return name2.startsWith(".") && !KEEP_DOTFILES.has(name2);
 }
 function rankFiles(paths, query, limit) {
   const q = query.toLowerCase();
@@ -1144,245 +1144,218 @@ async function handleMemoryForget(ws, msg, memoryStore) {
 }
 
 // src/server/mcp-handlers.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
-function isMcpServerRecord(val) {
-  if (typeof val !== "object" || val === null) return false;
-  return true;
+import { allServers } from "@wrongstack/core";
+import {
+  addMcp,
+  disableMcp,
+  discoverMcp,
+  enableMcp,
+  listMcp,
+  removeMcp,
+  restartMcp,
+  updateMcp
+} from "@wrongstack/mcp";
+function mapStatus(raw) {
+  switch (raw) {
+    case "connected":
+      return "connected";
+    case "connecting":
+    case "reconnecting":
+      return "connecting";
+    case "failed":
+      return "error";
+    case "dormant":
+      return "sleeping";
+    default:
+      return "stopped";
+  }
 }
-function projectServer(name, cfg, _status = "stopped", tools = []) {
-  return {
-    name,
-    transport: cfg.transport,
-    status: _status,
-    enabled: cfg.enabled ?? true,
-    description: cfg.description,
-    tools
+function toView(info) {
+  const view = {
+    name: info.name,
+    transport: info.transport,
+    // A dormant lazy server is "asleep", not stopped — preserve that even when
+    // it's enabled in config.
+    status: info.status === "dormant" ? "sleeping" : info.enabled === false ? "stopped" : mapStatus(info.status),
+    enabled: info.enabled,
+    tools: info.tools
   };
+  if (info.description !== void 0) view.description = info.description;
+  if (info.lazy !== void 0) view.lazy = info.lazy;
+  return view;
 }
-async function readConfig(configPath) {
-  try {
-    const content = await fs3.readFile(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
+function deps(ws, globalConfigPath, registry) {
+  if (!registry || !globalConfigPath) {
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: false, message: "MCP registry is not available in this session." }
+    });
+    return null;
   }
+  return { configPath: globalConfigPath, registry, presets: allServers() };
 }
-async function writeConfig(configPath, cfg) {
-  const dir = path3.dirname(configPath);
-  await fs3.mkdir(dir, { recursive: true });
-  await fs3.writeFile(configPath, JSON.stringify(cfg, null, 2), "utf-8");
+function name(msg) {
+  return msg.payload?.name ?? "";
 }
-async function getMcpServers(config, globalConfigPath) {
-  const servers = [];
-  const configured = isMcpServerRecord(config.mcpServers) ? config.mcpServers : {};
-  for (const [name, cfg] of Object.entries(configured)) {
-    servers.push(projectServer(name, cfg));
+async function handleMcpList(ws, _msg, globalConfigPath, mcpRegistry) {
+  if (!mcpRegistry || !globalConfigPath) {
+    send(ws, { type: "mcp.list", payload: { servers: [] } });
+    return;
   }
-  return servers;
+  const servers = await listMcp({
+    configPath: globalConfigPath,
+    registry: mcpRegistry,
+    presets: allServers()
+  });
+  send(ws, { type: "mcp.list", payload: { servers: servers.map(toView) } });
 }
-function getRegistryStates(mcpRegistry) {
-  const states = /* @__PURE__ */ new Map();
-  if (!mcpRegistry?.list) return states;
-  try {
-    const list = mcpRegistry.list();
-    for (const item of list) {
-      states.set(item.name, { state: item.state, toolCount: item.toolCount });
+async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await addMcp(msg.payload, d);
+  if (result.ok && result.server) {
+    send(ws, { type: "mcp.server.added", payload: { server: toView(result.server) } });
+    if (result.registryError) {
+      send(ws, {
+        type: "mcp.server.error",
+        payload: { name: result.server.name, error: result.registryError }
+      });
+    } else if (result.server.enabled) {
+      send(ws, { type: "mcp.server.connected", payload: { name: result.server.name } });
     }
-  } catch {
   }
-  return states;
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpList(ws, _msg, config, _globalConfigPath, mcpRegistry) {
-  const servers = await getMcpServers(config, _globalConfigPath);
-  const registryStates = getRegistryStates(mcpRegistry);
-  for (const server of servers) {
-    const registryState = registryStates.get(server.name);
-    if (registryState) {
-      server.status = registryState.state;
-      server.tools = Array.from({ length: registryState.toolCount }, (_, i) => `tool-${i + 1}`);
-    }
+async function handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await updateMcp(msg.payload, d);
+  if (result.ok && result.server) {
+    send(ws, { type: "mcp.server.updated", payload: { server: toView(result.server) } });
   }
-  send(ws, { type: "mcp.list", payload: { servers } });
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpAdd(ws, msg, config, globalConfigPath, mcpRegistry) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
-  }
-  try {
-    const diskConfig = await readConfig(globalConfigPath);
-    const mcpServers = isMcpServerRecord(diskConfig.mcpServers) ? diskConfig.mcpServers : {};
-    if (mcpServers[payload.name]) {
-      send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Server "${payload.name}" already exists` } });
-      return;
-    }
-    mcpServers[payload.name] = {
-      transport: payload.transport,
-      description: payload.description,
-      enabled: payload.enabled ?? true,
-      command: payload.command,
-      args: payload.args,
-      env: payload.env,
-      allowedTools: payload.allowedTools
-    };
-    diskConfig.mcpServers = mcpServers;
-    await writeConfig(globalConfigPath, diskConfig);
-    const newServer = projectServer(payload.name, mcpServers[payload.name]);
-    send(ws, { type: "mcp.server.added", payload: { server: newServer } });
-    if (mcpRegistry && (payload.enabled ?? true)) {
-      const serverConfig = mcpServers[payload.name];
-      try {
-        await mcpRegistry.start({
-          name: payload.name,
-          transport: payload.transport,
-          command: payload.command,
-          args: payload.args,
-          env: payload.env,
-          allowedTools: payload.allowedTools,
-          enabled: true
-        });
-      } catch (err) {
-        send(ws, { type: "mcp.server.error", payload: { name: payload.name, error: String(err) } });
-      }
-    }
-    send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" added` } });
-  } catch (err) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Failed to add server: ${err}` } });
+async function handleMcpRemove(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await removeMcp(name(msg), d);
+  if (result.ok) {
+    send(ws, { type: "mcp.server.removed", payload: { name: name(msg) } });
   }
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpRemove(ws, msg, _config, globalConfigPath, mcpRegistry) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
-  }
-  try {
-    if (mcpRegistry) {
-      try {
-        await mcpRegistry.stop(payload.name);
-      } catch {
-      }
-    }
-    const diskConfig = await readConfig(globalConfigPath);
-    const mcpServers = isMcpServerRecord(diskConfig.mcpServers) ? diskConfig.mcpServers : {};
-    if (!mcpServers[payload.name]) {
-      send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Server "${payload.name}" not found` } });
-      return;
+async function handleMcpEnable(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await enableMcp(name(msg), d);
+  if (result.ok && result.server) {
+    send(ws, { type: "mcp.server.updated", payload: { server: toView(result.server) } });
+    if (result.registryError) {
+      send(ws, {
+        type: "mcp.server.error",
+        payload: { name: name(msg), error: result.registryError }
+      });
+    } else {
+      send(ws, { type: "mcp.server.connected", payload: { name: name(msg) } });
     }
-    delete mcpServers[payload.name];
-    diskConfig.mcpServers = mcpServers;
-    await writeConfig(globalConfigPath, diskConfig);
-    send(ws, { type: "mcp.server.removed", payload: { name: payload.name } });
-    send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" removed` } });
-  } catch (err) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Failed to remove server: ${err}` } });
   }
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpUpdate(ws, msg, _config, globalConfigPath) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
-  }
-  try {
-    const diskConfig = await readConfig(globalConfigPath);
-    const mcpServers = isMcpServerRecord(diskConfig.mcpServers) ? diskConfig.mcpServers : {};
-    if (!mcpServers[payload.name]) {
-      send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Server "${payload.name}" not found` } });
-      return;
+async function handleMcpDisable(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await disableMcp(name(msg), d);
+  if (result.ok) {
+    send(ws, { type: "mcp.server.sleeping", payload: { name: name(msg) } });
+    if (result.server) {
+      send(ws, { type: "mcp.server.updated", payload: { server: toView(result.server) } });
     }
-    const existing = mcpServers[payload.name];
-    mcpServers[payload.name] = {
-      transport: payload.transport ?? existing.transport,
-      description: payload.description ?? existing.description,
-      enabled: payload.enabled ?? existing.enabled,
-      command: payload.command ?? existing.command,
-      args: payload.args ?? existing.args,
-      env: payload.env ?? existing.env,
-      allowedTools: payload.allowedTools ?? existing.allowedTools
-    };
-    diskConfig.mcpServers = mcpServers;
-    await writeConfig(globalConfigPath, diskConfig);
-    const updatedServer = projectServer(payload.name, mcpServers[payload.name]);
-    send(ws, { type: "mcp.server.updated", payload: { server: updatedServer } });
-    send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" updated` } });
-  } catch (err) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Failed to update server: ${err}` } });
-  }
-}
-async function handleMcpWake(ws, msg, _config, _globalConfigPath, mcpRegistry) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
-  }
-  if (!mcpRegistry) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "MCP registry not available" } });
-    return;
-  }
-  try {
-    send(ws, { type: "mcp.server.waking", payload: { name: payload.name } });
-    await mcpRegistry.restart(payload.name);
-    send(ws, { type: "mcp.server.connected", payload: { name: payload.name } });
-    send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" restarted` } });
-  } catch (err) {
-    send(ws, { type: "mcp.server.error", payload: { name: payload.name, error: String(err) } });
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Failed to restart "${payload.name}": ${err}` } });
   }
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpSleep(ws, msg, _config, _globalConfigPath, mcpRegistry) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
-  }
-  if (!mcpRegistry) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "MCP registry not available" } });
-    return;
-  }
+async function handleMcpSleep(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
   try {
-    await mcpRegistry.stop(payload.name);
-    send(ws, { type: "mcp.server.sleeping", payload: { name: payload.name } });
-    send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" stopped` } });
+    await d.registry.stop(name(msg));
+    send(ws, { type: "mcp.server.sleeping", payload: { name: name(msg) } });
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: true, message: `Server "${name(msg)}" stopped` }
+    });
   } catch (err) {
-    send(ws, { type: "mcp.server.error", payload: { name: payload.name, error: String(err) } });
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: `Failed to stop "${payload.name}": ${err}` } });
-  }
-}
-async function handleMcpDiscover(ws, msg, _config, _globalConfigPath, _mcpRegistry) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
+    const error = err instanceof Error ? err.message : String(err);
+    send(ws, { type: "mcp.server.error", payload: { name: name(msg), error } });
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: false, message: `Failed to stop "${name(msg)}": ${error}` }
+    });
   }
-  send(ws, { type: "mcp.server.discovered", payload: { name: payload.name, tools: [] } });
-  send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Server "${payload.name}" tools were discovered on connect` } });
 }
-async function handleMcpEnable(ws, msg, _config, _globalConfigPath) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
+async function handleMcpWake(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  send(ws, { type: "mcp.server.waking", payload: { name: name(msg) } });
+  const result = await restartMcp(name(msg), d);
+  if (result.ok && !result.registryError) {
+    send(ws, { type: "mcp.server.connected", payload: { name: name(msg) } });
+  } else if (result.registryError) {
+    send(ws, {
+      type: "mcp.server.error",
+      payload: { name: name(msg), error: result.registryError }
+    });
   }
-  send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Enable command sent for "${payload.name}"` } });
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpDisable(ws, msg, _config, _globalConfigPath) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
+async function handleMcpRestart(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await restartMcp(name(msg), d);
+  if (result.ok && !result.registryError) {
+    send(ws, { type: "mcp.server.connected", payload: { name: name(msg) } });
+  } else if (result.registryError) {
+    send(ws, {
+      type: "mcp.server.error",
+      payload: { name: name(msg), error: result.registryError }
+    });
   }
-  send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Disable command sent for "${payload.name}"` } });
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
-async function handleMcpRestart(ws, msg, _config, _globalConfigPath) {
-  const payload = msg.payload;
-  if (!payload.name) {
-    send(ws, { type: "mcp.operation_result", payload: { success: false, message: "Server name is required" } });
-    return;
+async function handleMcpDiscover(ws, msg, globalConfigPath, mcpRegistry) {
+  const d = deps(ws, globalConfigPath, mcpRegistry);
+  if (!d) return;
+  const result = await discoverMcp(name(msg), d);
+  if (result.ok) {
+    send(ws, {
+      type: "mcp.server.discovered",
+      payload: { name: name(msg), tools: result.tools ?? [] }
+    });
   }
-  send(ws, { type: "mcp.operation_result", payload: { success: true, message: `Restart command sent for "${payload.name}"` } });
+  send(ws, {
+    type: "mcp.operation_result",
+    payload: { success: result.ok, message: result.message }
+  });
 }
 
 // src/server/index.ts
@@ -1418,12 +1391,14 @@ import {
   repairToolUseAdjacency,
   resolveContextWindowPolicy,
   enhanceUserPrompt,
-  recentTextTurns
+  recentTextTurns,
+  resolveProviderModelList
 } from "@wrongstack/core";
 import { ToolExecutor } from "@wrongstack/core/execution";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets as encryptConfigSecrets2 } from "@wrongstack/core/security";
 import { buildProviderFactoriesFromRegistry, makeProviderFromConfig } from "@wrongstack/providers";
 import { builtinToolsPack, forgetTool, rememberTool, searchMemoryTool, relatedMemoryTool } from "@wrongstack/tools";
+import { MCPRegistry } from "@wrongstack/mcp";
 import { WebSocketServer } from "ws";
 
 // ../runtime/src/container.ts
@@ -2670,9 +2645,9 @@ var WorktreeWebSocketHandler = class {
 
 // src/server/mailbox-handlers.ts
 import { GlobalMailbox, resolveProjectDir } from "@wrongstack/core";
-async function handleMailboxMessages(ws, deps, payload) {
+async function handleMailboxMessages(ws, deps2, payload) {
   try {
-    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const dir = resolveProjectDir(deps2.projectRoot, deps2.globalRoot);
     const mb = new GlobalMailbox(dir);
     const messages = await mb.query({
       limit: payload?.limit ?? 30,
@@ -2706,9 +2681,9 @@ async function handleMailboxMessages(ws, deps, payload) {
     send(ws, { type: "mailbox.messages", payload: { messages: [], error: errMessage(err) } });
   }
 }
-async function handleMailboxAgents(ws, deps, payload) {
+async function handleMailboxAgents(ws, deps2, payload) {
   try {
-    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const dir = resolveProjectDir(deps2.projectRoot, deps2.globalRoot);
     const mb = new GlobalMailbox(dir);
     const agents = payload?.onlineOnly ? await mb.getOnlineAgents() : await mb.getAgentStatuses();
     send(ws, {
@@ -2735,9 +2710,9 @@ async function handleMailboxAgents(ws, deps, payload) {
     send(ws, { type: "mailbox.agents", payload: { agents: [], error: errMessage(err) } });
   }
 }
-async function handleMailboxClear(ws, deps) {
+async function handleMailboxClear(ws, deps2) {
   try {
-    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const dir = resolveProjectDir(deps2.projectRoot, deps2.globalRoot);
     const mb = new GlobalMailbox(dir);
     await mb.clearAll();
     send(ws, { type: "mailbox.cleared", payload: {} });
@@ -2745,9 +2720,9 @@ async function handleMailboxClear(ws, deps) {
     send(ws, { type: "mailbox.cleared", payload: { error: errMessage(err) } });
   }
 }
-async function handleMailboxPurge(ws, deps, opts) {
+async function handleMailboxPurge(ws, deps2, opts) {
   try {
-    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const dir = resolveProjectDir(deps2.projectRoot, deps2.globalRoot);
     const mb = new GlobalMailbox(dir);
     const result = await mb.purgeStale(opts);
     send(ws, { type: "mailbox.purged", payload: result });
@@ -2794,14 +2769,14 @@ function registerShutdownHandlers(res) {
 
 // src/server/instance-registry.ts
 import * as os from "os";
-import * as path4 from "path";
-import * as fs4 from "fs/promises";
+import * as path3 from "path";
+import * as fs3 from "fs/promises";
 import { atomicWrite as atomicWrite2 } from "@wrongstack/core";
 function defaultBaseDir() {
-  return path4.join(os.homedir(), ".wrongstack");
+  return path3.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path4.join(baseDir, "webui-instances.json");
+  return path3.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -2814,7 +2789,7 @@ function isPidAlive(pid) {
 }
 async function load(file) {
   try {
-    const raw = await fs4.readFile(file, "utf8");
+    const raw = await fs3.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.version === 1 && Array.isArray(parsed.instances)) {
       return parsed;
@@ -2962,15 +2937,15 @@ import { DefaultSecretScrubber as DefaultSecretScrubber2 } from "@wrongstack/cor
 import { probeLocalLlm } from "@wrongstack/runtime/probe";
 
 // src/server/provider-config-io.ts
-import * as fs5 from "fs/promises";
-import * as path5 from "path";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
 import { atomicWrite as atomicWrite3 } from "@wrongstack/core";
 import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
 import { DefaultSecretVault } from "@wrongstack/core";
 async function loadSavedProviders(configPath, vault) {
   let raw;
   try {
-    raw = await fs5.readFile(configPath, "utf8");
+    raw = await fs4.readFile(configPath, "utf8");
   } catch {
     return {};
   }
@@ -2987,7 +2962,7 @@ async function saveProviders(configPath, vault, providers) {
   let raw;
   let fileExists = true;
   try {
-    raw = await fs5.readFile(configPath, "utf8");
+    raw = await fs4.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(
@@ -3137,9 +3112,9 @@ function projectSavedProviders(providers) {
   });
 }
 var probeScrubber = new DefaultSecretScrubber2();
-function createProviderHandlers(deps) {
-  const { globalConfigPath, vault, broadcast: broadcast2, clients } = deps;
-  let configWriteLock = deps.getConfigWriteLock();
+function createProviderHandlers(deps2) {
+  const { globalConfigPath, vault, broadcast: broadcast2, clients } = deps2;
+  let configWriteLock = deps2.getConfigWriteLock();
   async function loadConfigProviders() {
     return loadSavedProviders(globalConfigPath, vault);
   }
@@ -3154,7 +3129,7 @@ function createProviderHandlers(deps) {
       }));
     });
     configWriteLock = next;
-    deps.setConfigWriteLock(next);
+    deps2.setConfigWriteLock(next);
     await next;
   }
   async function handleKeyUpsert(ws, providerId, label, apiKey) {
@@ -3310,11 +3285,11 @@ function createProviderHandlers(deps) {
 }
 
 // src/server/setup-events.ts
-import * as fs6 from "fs/promises";
+import * as fs5 from "fs/promises";
 import { watch as fsWatch } from "fs";
-import * as path6 from "path";
-function setupEvents(deps) {
-  const { events, broadcast: broadcast2, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge, wpaths, watcherMetrics, onFleetBroadcaster } = deps;
+import * as path5 from "path";
+function setupEvents(deps2) {
+  const { events, broadcast: broadcast2, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge, wpaths, watcherMetrics, onFleetBroadcaster } = deps2;
   const disposers = [];
   events.on("iteration.started", (e) => {
     const maxIt = typeof context.meta["maxIterations"] === "number" ? context.meta["maxIterations"] : config.tools?.maxIterations ?? 100;
@@ -3521,16 +3496,16 @@ function setupEvents(deps) {
     if (wpaths?.projectStatus) {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
-        const dir = path6.dirname(statusFile);
-        await fs6.mkdir(dir, { recursive: true });
-        await fs6.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
+        const dir = path5.dirname(statusFile);
+        await fs5.mkdir(dir, { recursive: true });
+        await fs5.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
       } catch (err) {
         console.error("[setup-events] Failed to write status.json:", err);
       }
     }
   });
   if (wpaths?.projectStatus && wpaths.configDir) {
-    const projectsDir = path6.join(wpaths.configDir, "projects");
+    const projectsDir = path5.join(wpaths.configDir, "projects");
     const knownProjectHashes = /* @__PURE__ */ new Set();
     const debounceTimers = /* @__PURE__ */ new Map();
     const DEBOUNCE_MS = 150;
@@ -3593,20 +3568,20 @@ function setupEvents(deps) {
     let watcher;
     const startWatcher = async () => {
       try {
-        await fs6.mkdir(projectsDir, { recursive: true });
+        await fs5.mkdir(projectsDir, { recursive: true });
         watcher = fsWatch(projectsDir, { persistent: true, recursive: true }, async (eventType, filename) => {
           if (eventType === "change") {
             if (filename == null) return;
             if (watcherMetrics) watcherMetrics.fileChangesDetected++;
-            const targetFile = path6.join(projectsDir, String(filename));
+            const targetFile = path5.join(projectsDir, String(filename));
             if (targetFile.endsWith("status.json")) {
-              const projectHash2 = path6.basename(path6.dirname(targetFile));
+              const projectHash2 = path5.basename(path5.dirname(targetFile));
               if (knownProjectHashes.size > 0 && !knownProjectHashes.has(projectHash2)) {
                 return;
               }
               if (watcherMetrics) watcherMetrics.filesProcessed++;
               try {
-                const content = await fs6.readFile(targetFile, "utf-8");
+                const content = await fs5.readFile(targetFile, "utf-8");
                 const statusData = JSON.parse(content);
                 if (statusData.projectHash) {
                   const hash = String(statusData.projectHash);
@@ -3658,7 +3633,7 @@ function setupEvents(deps) {
       }
     });
   }
-  const globalRoot = globalConfigPath ? path6.dirname(globalConfigPath) : void 0;
+  const globalRoot = globalConfigPath ? path5.dirname(globalConfigPath) : void 0;
   if (globalRoot) {
     const broadcastSessions = async () => {
       try {
@@ -3706,8 +3681,8 @@ function setupEvents(deps) {
     let regDebounce;
     try {
       const regWatcher = fsWatch(globalRoot, { persistent: false }, (_event, filename) => {
-        const name = filename ? String(filename) : "";
-        if (!name.startsWith("session-registry.json") || name.endsWith(".lock")) return;
+        const name2 = filename ? String(filename) : "";
+        if (!name2.startsWith("session-registry.json") || name2.endsWith(".lock")) return;
         if (regDebounce) clearTimeout(regDebounce);
         regDebounce = setTimeout(() => void broadcastSessions(), 150);
       });
@@ -3731,11 +3706,11 @@ function setupEvents(deps) {
 
 // src/server/custom-context-modes.ts
 import { listContextWindowModes, atomicWrite as atomicWrite4 } from "@wrongstack/core";
-import * as fs7 from "fs/promises";
-import * as path7 from "path";
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
 var STORE_FILENAME = "custom-context-modes.json";
 function storePath(wrongstackDir) {
-  return path7.join(wrongstackDir, STORE_FILENAME);
+  return path6.join(wrongstackDir, STORE_FILENAME);
 }
 var BUILTIN_IDS = /* @__PURE__ */ new Set(["balanced", "frugal", "deep", "archival"]);
 function createCustomModeStore(wrongstackDir) {
@@ -3743,7 +3718,7 @@ function createCustomModeStore(wrongstackDir) {
   const load2 = async () => {
     modes.clear();
     try {
-      const raw = await fs7.readFile(storePath(wrongstackDir), "utf8");
+      const raw = await fs6.readFile(storePath(wrongstackDir), "utf8");
       const parsed = JSON.parse(raw);
       if (Array.isArray(parsed.modes)) {
         for (const m of parsed.modes) {
@@ -3923,14 +3898,14 @@ function createEternalSubscription(subscribe, broadcast2, clientsRef) {
 }
 
 // src/server/shell-open.ts
-import * as fs8 from "fs/promises";
-import * as path8 from "path";
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
 import { spawn as spawn2 } from "child_process";
 var METACHAR_REGEX = /[&|<>^"'`\n\r]/;
 async function handleShellOpen(req, logger) {
   try {
-    const resolved = path8.resolve(req.path);
-    await fs8.access(resolved);
+    const resolved = path7.resolve(req.path);
+    await fs7.access(resolved);
     if (METACHAR_REGEX.test(resolved)) {
       return { success: false, message: "Path contains unsupported characters." };
     }
@@ -4006,10 +3981,148 @@ async function handleGitInfo(ws, projectRoot) {
     send(ws, { type: "git.info", payload: { branch: "", added: 0, deleted: 0, untracked: 0, ahead: 0, behind: 0 } });
   }
 }
+function makeGit(cwd) {
+  return async (args) => {
+    const { execFile: ef } = await import("child_process");
+    return new Promise((resolve5) => {
+      ef(
+        "git",
+        args,
+        { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 * 16 },
+        (err, stdout) => resolve5(err ? "" : stdout)
+      );
+    });
+  };
+}
+async function handleGitChanges(ws, projectRoot) {
+  const cwd = projectRoot || void 0;
+  try {
+    const git = makeGit(cwd);
+    const [statusRaw, unstagedNumstat, stagedNumstat] = await Promise.all([
+      git(["status", "--porcelain", "-z"]),
+      git(["diff", "--numstat", "-z"]),
+      git(["diff", "--cached", "--numstat", "-z"])
+    ]);
+    const counts = /* @__PURE__ */ new Map();
+    const parseNumstat = (raw) => {
+      const parts = raw.split("\0");
+      for (let i = 0; i < parts.length; i++) {
+        const entry = parts[i];
+        if (!entry) continue;
+        const m = /^(\d+|-)\t(\d+|-)\t(.*)$/.exec(entry);
+        if (!m) continue;
+        const added = m[1] === "-" ? 0 : Number(m[1]);
+        const deleted = m[2] === "-" ? 0 : Number(m[2]);
+        let path10 = m[3] ?? "";
+        if (path10 === "") {
+          i += 1;
+          path10 = parts[i + 1] ?? parts[i] ?? "";
+          i += 1;
+        }
+        if (!path10) continue;
+        const prev = counts.get(path10) ?? { added: 0, deleted: 0 };
+        counts.set(path10, { added: prev.added + added, deleted: prev.deleted + deleted });
+      }
+    };
+    parseNumstat(unstagedNumstat);
+    parseNumstat(stagedNumstat);
+    const records = statusRaw.split("\0").filter((r) => r.length > 0);
+    const files = [];
+    for (let i = 0; i < records.length; i++) {
+      const rec = records[i];
+      if (!rec || rec.length < 3) continue;
+      const x = rec[0] ?? " ";
+      const y = rec[1] ?? " ";
+      const path10 = rec.slice(3);
+      const isRename = x === "R" || x === "C" || y === "R" || y === "C";
+      if (isRename) i += 1;
+      let status;
+      if (x === "?" && y === "?") status = "?";
+      else if (x === "U" || y === "U" || x === "A" && y === "A" || x === "D" && y === "D") status = "U";
+      else if (x === "R" || y === "R") status = "R";
+      else if (x === "C" || y === "C") status = "C";
+      else if (x === "A" || y === "A") status = "A";
+      else if (x === "D" || y === "D") status = "D";
+      else status = "M";
+      const staged = x !== " " && x !== "?";
+      let added = counts.get(path10)?.added ?? 0;
+      let deleted = counts.get(path10)?.deleted ?? 0;
+      if (status === "?") {
+        added = await countUntrackedLines(cwd, path10);
+        deleted = 0;
+      }
+      files.push({ path: path10, status, added, deleted, staged });
+    }
+    send(ws, { type: "git.changes", payload: { files } });
+  } catch (err) {
+    send(ws, {
+      type: "git.changes",
+      payload: { files: [], error: err instanceof Error ? err.message : String(err) }
+    });
+  }
+}
+async function countUntrackedLines(cwd, relPath) {
+  try {
+    const { readFile: readFile8 } = await import("fs/promises");
+    const { join: join8 } = await import("path");
+    const abs = cwd ? join8(cwd, relPath) : relPath;
+    const buf = await readFile8(abs);
+    if (buf.includes(0)) return 0;
+    if (buf.length === 0) return 0;
+    let lines = 0;
+    for (let i = 0; i < buf.length; i++) if (buf[i] === 10) lines++;
+    if (buf[buf.length - 1] !== 10) lines++;
+    return lines;
+  } catch {
+    return 0;
+  }
+}
+var MAX_DIFF_BYTES = 2 * 1024 * 1024;
+async function handleGitDiff(ws, projectRoot, path10) {
+  const cwd = projectRoot || void 0;
+  const reply = (extra) => send(ws, { type: "git.diff", payload: { path: path10, ...extra } });
+  if (!path10 || path10.includes("\0") || path10.includes("..")) {
+    reply({ oldText: "", newText: "", error: "invalid path" });
+    return;
+  }
+  try {
+    const git = makeGit(cwd);
+    const { readFile: readFile8 } = await import("fs/promises");
+    const { join: join8 } = await import("path");
+    const oldText = await git(["show", `HEAD:${path10}`]);
+    let newText = "";
+    try {
+      const abs = cwd ? join8(cwd, path10) : path10;
+      const buf = await readFile8(abs);
+      if (buf.includes(0)) {
+        reply({ oldText: "", newText: "", binary: true });
+        return;
+      }
+      if (buf.length > MAX_DIFF_BYTES) {
+        reply({ oldText: "", newText: "", tooLarge: true });
+        return;
+      }
+      newText = buf.toString("utf8");
+    } catch {
+      newText = "";
+    }
+    if ((oldText.length || 0) > MAX_DIFF_BYTES) {
+      reply({ oldText: "", newText: "", tooLarge: true });
+      return;
+    }
+    if (oldText.includes("\0")) {
+      reply({ oldText: "", newText: "", binary: true });
+      return;
+    }
+    reply({ oldText, newText });
+  } catch (err) {
+    reply({ oldText: "", newText: "", error: err instanceof Error ? err.message : String(err) });
+  }
+}
 
 // src/server/skills-handlers.ts
-import { promises as fs9 } from "fs";
-import path9 from "path";
+import { promises as fs8 } from "fs";
+import path8 from "path";
 import JSZip from "jszip";
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
 
@@ -4100,6 +4213,21 @@ async function startWebUI(opts = {}) {
   toolRegistry.register(makeMailSendTool({ projectDir: wpaths.projectDir, events }));
   toolRegistry.register(makeMailInboxTool({ projectDir: wpaths.projectDir, events }));
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
+  const mcpRegistry = new MCPRegistry({
+    toolRegistry,
+    events,
+    log: logger,
+    // Lazy-connect (per-server `lazy`) manifest cache + default idle auto-sleep.
+    cacheDir: wpaths.cacheDir
+  });
+  if (config.features.mcp && config.mcpServers) {
+    for (const [name2, cfg] of Object.entries(config.mcpServers)) {
+      if (cfg.enabled === false) continue;
+      void mcpRegistry.start({ ...cfg, name: name2 }).catch((err) => {
+        logger.warn(`MCP server "${name2}" failed to start at boot`, err);
+      });
+    }
+  }
   let sessionStore = opts.services?.session ?? new DefaultSessionStore2({ dir: wpaths.projectSessions });
   if (!opts.services?.session) {
     sessionStore.prune(DEFAULT_SESSION_PRUNE_DAYS).then((count) => {
@@ -4127,7 +4255,7 @@ async function startWebUI(opts = {}) {
       sessionId: session.id,
       projectSlug: wpaths.projectSlug,
       projectRoot,
-      projectName: path10.basename(projectRoot),
+      projectName: path9.basename(projectRoot),
       workingDir,
       clientType: "webui",
       pid: process.pid,
@@ -4183,9 +4311,9 @@ async function startWebUI(opts = {}) {
   } : void 0;
   const skillLoader = config.features.skills ? new DefaultSkillLoader2({ paths: wpaths }) : void 0;
   const skillInstaller = config.features.skills ? new SkillInstaller({
-    manifestPath: path10.join(wstackGlobalRoot2(), "installed-skills.json"),
-    projectSkillsDir: path10.join(projectRoot, ".wrongstack", "skills"),
-    globalSkillsDir: path10.join(wstackGlobalRoot2(), "skills"),
+    manifestPath: path9.join(wstackGlobalRoot2(), "installed-skills.json"),
+    projectSkillsDir: path9.join(projectRoot, ".wrongstack", "skills"),
+    globalSkillsDir: path9.join(wstackGlobalRoot2(), "skills"),
     projectHash: projectHash(projectRoot),
     skillLoader
   }) : void 0;
@@ -4346,7 +4474,7 @@ async function startWebUI(opts = {}) {
     const write = async () => {
       let raw;
       try {
-        raw = await fs10.readFile(globalConfigPath, "utf8");
+        raw = await fs9.readFile(globalConfigPath, "utf8");
       } catch {
         raw = "{}";
       }
@@ -4655,7 +4783,7 @@ async function startWebUI(opts = {}) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path10.basename(projectRoot) || projectRoot,
+      projectName: path9.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: workingDir,
       mode: modeId,
@@ -4870,33 +4998,33 @@ async function startWebUI(opts = {}) {
     });
   }
   async function touchProjectEntry(root, workDir) {
-    const resolved = path10.resolve(root);
+    const resolved = path9.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = manifest.projects.find((p) => path10.resolve(p.root) === resolved);
+    const existing = manifest.projects.find((p) => path9.resolve(p.root) === resolved);
     if (existing) {
       existing.lastSeen = now;
-      if (workDir) existing.lastWorkingDir = path10.resolve(workDir);
+      if (workDir) existing.lastWorkingDir = path9.resolve(workDir);
     } else {
       manifest.projects.push({
-        name: path10.basename(resolved),
+        name: path9.basename(resolved),
         root: resolved,
         slug: generateProjectSlug(resolved),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: workDir ? path10.resolve(workDir) : void 0
+        lastWorkingDir: workDir ? path9.resolve(workDir) : void 0
       });
     }
     await saveManifest(manifest, globalConfigPath);
     await ensureProjectDataDir(generateProjectSlug(resolved), globalConfigPath);
   }
   function projectsJsonPath(globalConfigPath2) {
-    const base = path10.dirname(globalConfigPath2);
-    return path10.join(base, "projects.json");
+    const base = path9.dirname(globalConfigPath2);
+    return path9.join(base, "projects.json");
   }
   async function loadManifest(globalConfigPath2) {
     try {
-      const raw = await fs10.readFile(projectsJsonPath(globalConfigPath2), "utf8");
+      const raw = await fs9.readFile(projectsJsonPath(globalConfigPath2), "utf8");
       const parsed = JSON.parse(raw);
       return { projects: parsed.projects ?? [] };
     } catch {
@@ -4905,16 +5033,16 @@ async function startWebUI(opts = {}) {
   }
   async function saveManifest(manifest, globalConfigPath2) {
     const file = projectsJsonPath(globalConfigPath2);
-    await fs10.mkdir(path10.dirname(file), { recursive: true });
-    await fs10.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
+    await fs9.mkdir(path9.dirname(file), { recursive: true });
+    await fs9.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
   }
   function generateProjectSlug(rootPath) {
     return projectSlug(rootPath);
   }
   async function ensureProjectDataDir(slug, globalConfigPath2) {
-    const base = path10.dirname(globalConfigPath2);
-    const dir = path10.join(base, "projects", slug);
-    await fs10.mkdir(dir, { recursive: true });
+    const base = path9.dirname(globalConfigPath2);
+    const dir = path9.join(base, "projects", slug);
+    await fs9.mkdir(dir, { recursive: true });
     return dir;
   }
   async function handleMessage(ws, _client, msg) {
@@ -5220,27 +5348,17 @@ async function startWebUI(opts = {}) {
       }
       case "provider.models": {
         const providerId = msg.payload.providerId;
-        const provider2 = await modelsRegistry.getProvider(providerId);
-        if (provider2) {
-          send(ws, {
-            type: "provider.models",
-            payload: {
-              provider: providerId,
-              models: provider2.models.map((m) => ({
-                id: m.id,
-                name: m.name,
-                releaseDate: m.release_date,
-                contextWindow: m.limit?.context,
-                inputCost: m.cost?.input,
-                outputCost: m.cost?.output,
-                capabilities: [
-                  ...m.tool_call ? ["tools"] : [],
-                  ...m.reasoning ? ["reasoning"] : []
-                ]
-              }))
-            }
-          });
-        }
+        const saved = await providerHandlers.loadConfigProviders();
+        const cfg = saved[providerId];
+        const catalogId = cfg?.type && cfg.type !== providerId ? cfg.type : providerId;
+        const provider2 = await modelsRegistry.getProvider(catalogId);
+        send(ws, {
+          type: "provider.models",
+          payload: {
+            provider: providerId,
+            models: resolveProviderModelList(cfg?.models, provider2)
+          }
+        });
         break;
       }
       case "model.switch": {
@@ -5255,7 +5373,7 @@ async function startWebUI(opts = {}) {
           updateAutoCompactionMaxContext?.(newProv);
           try {
             const next = configWriteLock.then(async () => {
-              const raw = await fs10.readFile(globalConfigPath, "utf8");
+              const raw = await fs9.readFile(globalConfigPath, "utf8");
               const parsed = JSON.parse(raw);
               parsed.provider = newProvider;
               parsed.model = newModel;
@@ -5489,27 +5607,28 @@ async function startWebUI(opts = {}) {
         return handleMemoryRemember(ws, msg, memoryStore);
       case "memory.forget":
         return handleMemoryForget(ws, msg, memoryStore);
-      // ── MCP operations — delegated to shared handlers (mcp-handlers.ts) ──
+      // ── MCP operations — delegated to shared handlers (mcp-handlers.ts),
+      // backed by the live MCPRegistry constructed above. ──
       case "mcp.list":
-        return handleMcpList(ws, msg, config, globalConfigPath, void 0);
+        return handleMcpList(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.add":
-        return handleMcpAdd(ws, msg, config, globalConfigPath, void 0);
+        return handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.remove":
-        return handleMcpRemove(ws, msg, config, globalConfigPath, void 0);
+        return handleMcpRemove(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.update":
-        return handleMcpUpdate(ws, msg, config, globalConfigPath);
+        return handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.wake":
-        return handleMcpWake(ws, msg, config, globalConfigPath, void 0);
+        return handleMcpWake(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.sleep":
-        return handleMcpSleep(ws, msg, config, globalConfigPath, void 0);
+        return handleMcpSleep(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.discover":
-        return handleMcpDiscover(ws, msg, config, globalConfigPath);
+        return handleMcpDiscover(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.enable":
-        return handleMcpEnable(ws, msg, config, globalConfigPath);
+        return handleMcpEnable(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.disable":
-        return handleMcpDisable(ws, msg, config, globalConfigPath);
+        return handleMcpDisable(ws, msg, globalConfigPath, mcpRegistry);
       case "mcp.restart":
-        return handleMcpRestart(ws, msg, config, globalConfigPath);
+        return handleMcpRestart(ws, msg, globalConfigPath, mcpRegistry);
       case "skills.list": {
         if (!skillLoader) {
           send(ws, { type: "skills.list", payload: { skills: [], enabled: false } });
@@ -5571,33 +5690,33 @@ async function startWebUI(opts = {}) {
           break;
         }
         try {
-          const { name, source } = contentPayload;
+          const { name: name2, source } = contentPayload;
           const entries = await skillLoader.listEntries();
-          const entry = entries.find((e) => e.name.toLowerCase() === name.toLowerCase());
+          const entry = entries.find((e) => e.name.toLowerCase() === name2.toLowerCase());
           if (!entry) {
-            send(ws, { type: "skills.content", payload: { name, body: "", path: "", source, relatedFiles: [], references: [], error: `Skill "${name}" not found` } });
+            send(ws, { type: "skills.content", payload: { name: name2, body: "", path: "", source, relatedFiles: [], references: [], error: `Skill "${name2}" not found` } });
             break;
           }
-          const body = await skillLoader.readBody(name);
-          const skillDir = path10.dirname(entry.path);
+          const body = await skillLoader.readBody(name2);
+          const skillDir = path9.dirname(entry.path);
           let relatedFiles = [];
           try {
-            const files = await fs10.readdir(skillDir);
-            relatedFiles = files.filter((f) => f !== path10.basename(entry.path)).map((f) => path10.join(skillDir, f));
+            const files = await fs9.readdir(skillDir);
+            relatedFiles = files.filter((f) => f !== path9.basename(entry.path)).map((f) => path9.join(skillDir, f));
           } catch {
           }
           const refs = [];
           for (const e of entries) {
-            if (e.name.toLowerCase() === name.toLowerCase()) continue;
+            if (e.name.toLowerCase() === name2.toLowerCase()) continue;
             try {
               const content = await skillLoader.readBody(e.name);
-              if (content.toLowerCase().includes(name.toLowerCase())) {
+              if (content.toLowerCase().includes(name2.toLowerCase())) {
                 refs.push(e.name);
               }
             } catch {
             }
           }
-          send(ws, { type: "skills.content", payload: { name, body, path: entry.path, source, relatedFiles, references: refs } });
+          send(ws, { type: "skills.content", payload: { name: name2, body, path: entry.path, source, relatedFiles, references: refs } });
         } catch (err) {
           send(ws, { type: "skills.content", payload: { name: contentPayload.name, body: "", path: "", source: contentPayload.source, relatedFiles: [], references: [], error: errMessage(err) } });
         }
@@ -5690,14 +5809,14 @@ async function startWebUI(opts = {}) {
           break;
         }
         try {
-          const targetDir = createPayload.scope === "global" ? path10.join(wstackGlobalRoot2(), "skills", createPayload.name.trim()) : path10.join(projectRoot, ".wrongstack", "skills", createPayload.name.trim());
+          const targetDir = createPayload.scope === "global" ? path9.join(wstackGlobalRoot2(), "skills", createPayload.name.trim()) : path9.join(projectRoot, ".wrongstack", "skills", createPayload.name.trim());
           try {
-            await fs10.access(targetDir);
+            await fs9.access(targetDir);
             send(ws, { type: "skills.created", payload: { success: false, error: `Skill "${createPayload.name}" already exists` } });
             break;
           } catch {
           }
-          await fs10.mkdir(targetDir, { recursive: true });
+          await fs9.mkdir(targetDir, { recursive: true });
           const lines = createPayload.description.trim().split("\n");
           const firstLine = lines[0].trim();
           const bodyLines = lines.slice(1).map((l) => l.trim()).filter(Boolean);
@@ -5745,13 +5864,13 @@ ${trigger}
             "- `bug-hunter` \u2014 for systematic bug detection patterns",
             "- `output-standards` \u2014 for standardized `<next_steps>` formatting"
           ].join("\n");
-          await fs10.writeFile(path10.join(targetDir, "SKILL.md"), skillContent, "utf-8");
+          await fs9.writeFile(path9.join(targetDir, "SKILL.md"), skillContent, "utf-8");
           send(ws, {
             type: "skills.created",
             payload: {
               success: true,
               error: null,
-              skill: { name: createPayload.name.trim(), path: path10.join(targetDir, "SKILL.md"), scope: createPayload.scope }
+              skill: { name: createPayload.name.trim(), path: path9.join(targetDir, "SKILL.md"), scope: createPayload.scope }
             }
           });
         } catch (err) {
@@ -5784,7 +5903,7 @@ ${trigger}
             send(ws, { type: "skills.edited", payload: { success: false, error: "Bundled skills cannot be edited" } });
             break;
           }
-          await fs10.writeFile(entry.path, editPayload.body, "utf-8");
+          await fs9.writeFile(entry.path, editPayload.body, "utf-8");
           send(ws, { type: "skills.edited", payload: { success: true, error: null } });
         } catch (err) {
           send(ws, { type: "skills.edited", payload: { success: false, error: errMessage(err) } });
@@ -6073,6 +6192,14 @@ ${trigger}
         await handleGitInfo(ws, projectRoot);
         break;
       }
+      case "git.changes": {
+        await handleGitChanges(ws, projectRoot);
+        break;
+      }
+      case "git.diff": {
+        await handleGitDiff(ws, projectRoot, String(msg.payload?.path ?? ""));
+        break;
+      }
       case "webui.shutdown": {
         console.log("[WebUI] Shutdown requested from client");
         process.kill(process.pid, "SIGINT");
@@ -6081,7 +6208,7 @@ ${trigger}
       case "goal.get": {
         try {
           const goalPath = resolveWstackPaths({ projectRoot }).projectGoal;
-          const raw = await fs10.readFile(goalPath, "utf8");
+          const raw = await fs9.readFile(goalPath, "utf8");
           const goal = JSON.parse(raw);
           broadcast(clients, { type: "goal.updated", payload: goal });
         } catch {
@@ -6141,7 +6268,7 @@ ${trigger}
         try {
           const { DefaultSessionRewinder } = await import("@wrongstack/core");
           const rewinder = new DefaultSessionRewinder(
-            path10.join(projectRoot, ".wrongstack", "sessions"),
+            path9.join(projectRoot, ".wrongstack", "sessions"),
             projectRoot
           );
           const checkpoints = await rewinder.listCheckpoints(session.id);
@@ -6162,7 +6289,7 @@ ${trigger}
         try {
           const { DefaultSessionRewinder } = await import("@wrongstack/core");
           const rewinder = new DefaultSessionRewinder(
-            path10.join(projectRoot, ".wrongstack", "sessions"),
+            path9.join(projectRoot, ".wrongstack", "sessions"),
             projectRoot
           );
           await rewinder.rewindToCheckpoint(session.id, checkpointIndex);
@@ -6196,9 +6323,9 @@ ${trigger}
       case "projects.add": {
         const { root: addRoot, name: displayName } = msg.payload;
         try {
-          const resolved = path10.resolve(addRoot);
-          await fs10.access(resolved);
-          const stat2 = await fs10.stat(resolved);
+          const resolved = path9.resolve(addRoot);
+          await fs9.access(resolved);
+          const stat2 = await fs9.stat(resolved);
           if (!stat2.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
           const manifest = await loadManifest(globalConfigPath);
           const existing = manifest.projects.find((p) => p.root === resolved);
@@ -6214,26 +6341,26 @@ ${trigger}
             });
             break;
           }
-          const name = displayName?.trim() || path10.basename(resolved);
+          const name2 = displayName?.trim() || path9.basename(resolved);
           const slug = generateProjectSlug(resolved);
           await ensureProjectDataDir(slug, globalConfigPath);
           const now = (/* @__PURE__ */ new Date()).toISOString();
-          manifest.projects.push({ name, root: resolved, slug, lastSeen: now, createdAt: now });
+          manifest.projects.push({ name: name2, root: resolved, slug, lastSeen: now, createdAt: now });
           await saveManifest(manifest, globalConfigPath);
           send(ws, {
             type: "projects.added",
             payload: {
-              name,
+              name: name2,
               root: resolved,
               slug,
-              message: `Registered project "${name}"`
+              message: `Registered project "${name2}"`
             }
           });
         } catch (err) {
           send(ws, {
             type: "projects.added",
             payload: {
-              name: path10.basename(addRoot),
+              name: path9.basename(addRoot),
               root: addRoot,
               slug: "",
               message: errMessage(err)
@@ -6245,17 +6372,17 @@ ${trigger}
       case "projects.select": {
         const { root: selRoot, name: selName } = msg.payload;
         try {
-          const resolved = path10.resolve(selRoot);
+          const resolved = path9.resolve(selRoot);
           try {
-            await fs10.access(resolved);
-            const stat2 = await fs10.stat(resolved);
+            await fs9.access(resolved);
+            const stat2 = await fs9.stat(resolved);
             if (!stat2.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
           } catch (err) {
             send(ws, {
               type: "projects.selected",
               payload: {
                 root: selRoot,
-                name: selName || path10.basename(selRoot),
+                name: selName || path9.basename(selRoot),
                 message: `Cannot switch: ${errMessage(err)}`
               }
             });
@@ -6267,10 +6394,10 @@ ${trigger}
             entry.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
             entry.lastWorkingDir = resolved;
           } else {
-            const name = selName?.trim() || path10.basename(resolved);
+            const name2 = selName?.trim() || path9.basename(resolved);
             const slug = generateProjectSlug(resolved);
             manifest.projects.push({
-              name,
+              name: name2,
               root: resolved,
               slug,
               lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6308,13 +6435,13 @@ ${trigger}
             });
           } catch {
           }
-          const newSessionsDir = path10.join(
-            path10.dirname(globalConfigPath),
+          const newSessionsDir = path9.join(
+            path9.dirname(globalConfigPath),
             "projects",
             switchSlug,
             "sessions"
           );
-          await fs10.mkdir(newSessionsDir, { recursive: true });
+          await fs9.mkdir(newSessionsDir, { recursive: true });
           const newSessionStore = new DefaultSessionStore2({ dir: newSessionsDir });
           const oldSessionId = session.id;
           try {
@@ -6346,7 +6473,7 @@ ${trigger}
               sessionId: session.id,
               projectSlug: switchSlug,
               projectRoot,
-              projectName: path10.basename(projectRoot),
+              projectName: path9.basename(projectRoot),
               workingDir,
               clientType: "webui",
               pid: process.pid,
@@ -6358,8 +6485,8 @@ ${trigger}
             type: "projects.selected",
             payload: {
               root: resolved,
-              name: selName || path10.basename(resolved),
-              message: `Switched to ${selName || path10.basename(resolved)}`
+              name: selName || path9.basename(resolved),
+              message: `Switched to ${selName || path9.basename(resolved)}`
             }
           });
           broadcast(clients, {
@@ -6382,7 +6509,7 @@ ${trigger}
             type: "projects.selected",
             payload: {
               root: selRoot,
-              name: selName || path10.basename(selRoot),
+              name: selName || path9.basename(selRoot),
               message: errMessage(err)
             }
           });
@@ -6393,14 +6520,14 @@ ${trigger}
       case "working_dir.set": {
         const { path: newPath } = msg.payload;
         try {
-          const resolved = path10.resolve(projectRoot, newPath);
-          if (!resolved.startsWith(projectRoot + path10.sep) && resolved !== projectRoot) {
+          const resolved = path9.resolve(projectRoot, newPath);
+          if (!resolved.startsWith(projectRoot + path9.sep) && resolved !== projectRoot) {
             sendResult2(ws, false, `Path must stay inside the project root: ${projectRoot}`);
             break;
           }
           try {
-            await fs10.access(resolved);
-            const stat2 = await fs10.stat(resolved);
+            await fs9.access(resolved);
+            const stat2 = await fs9.stat(resolved);
             if (!stat2.isDirectory()) throw new Error("Not a directory");
           } catch {
             sendResult2(ws, false, `Directory not found or not accessible: ${resolved}`);
@@ -6431,24 +6558,24 @@ ${trigger}
       case "mailbox.messages":
         return handleMailboxMessages(
           ws,
-          { projectRoot, globalRoot: path10.dirname(globalConfigPath) },
+          { projectRoot, globalRoot: path9.dirname(globalConfigPath) },
           msg.payload
         );
       case "mailbox.agents":
         return handleMailboxAgents(
           ws,
-          { projectRoot, globalRoot: path10.dirname(globalConfigPath) },
+          { projectRoot, globalRoot: path9.dirname(globalConfigPath) },
           msg.payload
         );
       case "mailbox.clear":
         return handleMailboxClear(
           ws,
-          { projectRoot, globalRoot: path10.dirname(globalConfigPath) }
+          { projectRoot, globalRoot: path9.dirname(globalConfigPath) }
         );
       case "mailbox.purge":
         return handleMailboxPurge(
           ws,
-          { projectRoot, globalRoot: path10.dirname(globalConfigPath) },
+          { projectRoot, globalRoot: path9.dirname(globalConfigPath) },
           msg.payload
         );
       // ── Brain — status, autonomy ceiling, direct decision support ───
@@ -6527,7 +6654,7 @@ ${trigger}
   };
   const httpServer = createHttpServer({
     host: wsHost,
-    distDir: path10.resolve(import.meta.dirname, "../../dist"),
+    distDir: path9.resolve(import.meta.dirname, "../../dist"),
     wsPort,
     globalRoot: wpaths.globalRoot,
     apiToken: wsToken,
@@ -6536,7 +6663,7 @@ ${trigger}
       void fleetBroadcast?.();
     }
   });
-  const registryBaseDir = path10.dirname(globalConfigPath);
+  const registryBaseDir = path9.dirname(globalConfigPath);
   httpServer.listen(httpPort, wsHost, () => {
     const openUrl = `http://${wsHost}:${httpPort}`;
     console.log(`[WebUI] HTTP server running on ${openUrl}`);
@@ -6548,7 +6675,7 @@ ${trigger}
         wsPort,
         host: wsHost,
         projectRoot,
-        projectName: path10.basename(projectRoot) || projectRoot,
+        projectName: path9.basename(projectRoot) || projectRoot,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         url: `http://${wsHost}:${httpPort}`
       },
@@ -6575,6 +6702,7 @@ ${trigger}
     // reality. Crash exits are healed by the next register()/list() prune pass.
     onShutdown: () => {
       brainMonitor.stop();
+      void mcpRegistry.stopAll().catch(() => void 0);
       if (disposeEvents) {
         disposeEvents();
         disposeEvents = null;