@wrongstack/webui 0.148.0 → 0.236.0

package/dist/server/entry.js

@@ -1,8 +1,23 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/server/index.ts
-import { expectDefined as expectDefined2 } from "@wrongstack/core";
-import * as fs4 from "fs/promises";
-import * as path4 from "path";
+import { expectDefined as expectDefined2, GlobalMailbox as GlobalMailbox2, projectSlug, getSessionRegistry, AgentStatusTracker } from "@wrongstack/core";
+import { makeMailboxTool, makeMailSendTool, makeMailInboxTool, mailboxSessionTag } from "@wrongstack/core";
+import {
+  BrainMonitor,
+  DefaultBrainArbiter,
+  ObservableBrainArbiter,
+  createAutonomyBrain,
+  createTieredBrainArbiter
+} from "@wrongstack/core";
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
 
 // src/server/http-server.ts
 import * as fs from "fs/promises";
@@ -28,7 +43,7 @@ function injectWsPort(html, wsPort) {
 ${html}`;
 }
 function buildCspHeader(wsPort) {
-  return `default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' ws://127.0.0.1:${wsPort} wss://127.0.0.1:${wsPort} ws://[::1]:${wsPort} wss://[::1]:${wsPort}; img-src 'self' data:; font-src 'self' data:; object-src 'none'; base-uri 'self'; frame-ancestors 'none'; form-action 'self'`;
+  return `default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self' ws://127.0.0.1:${wsPort} wss://127.0.0.1:${wsPort} ws://[::1]:${wsPort} wss://[::1]:${wsPort}; img-src 'self' data:; font-src 'self' data:; worker-src 'self' blob:; object-src 'none'; base-uri 'self'; frame-ancestors 'none'; form-action 'self'`;
 }
 function isInsideDist(candidate, distDir) {
   const root = path.resolve(distDir);
@@ -42,6 +57,15 @@ function createHttpServer(opts) {
   return http.createServer(async (req, res) => {
     try {
       const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (url.pathname === "/api/sessions" && req.method === "GET") {
+        await handleApiSessions(res, opts.globalRoot);
+        return;
+      }
+      const agentsMatch = url.pathname.match(/^\/api\/sessions\/([^/]+)\/agents$/);
+      if (agentsMatch && req.method === "GET") {
+        await handleApiSessionAgents(res, opts.globalRoot, agentsMatch[1]);
+        return;
+      }
       let filePath;
       if (url.pathname === "/" || url.pathname === "") {
         filePath = path.join(distDir, "index.html");
@@ -98,6 +122,84 @@ function createHttpServer(opts) {
     }
   });
 }
+async function handleApiSessions(res, globalRoot) {
+  if (!globalRoot) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "SessionRegistry not available" }));
+    return;
+  }
+  try {
+    const { SessionRegistry } = await import("@wrongstack/core");
+    const registry = new SessionRegistry(globalRoot);
+    const sessions = await registry.list();
+    const result = sessions.map((s) => ({
+      sessionId: s.sessionId,
+      projectSlug: s.projectSlug,
+      projectName: s.projectName,
+      projectRoot: s.projectRoot,
+      workingDir: s.workingDir,
+      status: s.status,
+      pid: s.pid,
+      startedAt: s.startedAt,
+      lastHeartbeatAt: s.lastHeartbeatAt,
+      agentCount: s.agentCount,
+      agents: s.agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        status: a.status,
+        currentTool: a.currentTool,
+        iterations: a.iterations,
+        toolCalls: a.toolCalls,
+        lastActivityAt: a.lastActivityAt
+      }))
+    }));
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(result));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+async function handleApiSessionAgents(res, globalRoot, sessionId) {
+  if (!globalRoot) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "SessionRegistry not available" }));
+    return;
+  }
+  try {
+    const { SessionRegistry } = await import("@wrongstack/core");
+    const registry = new SessionRegistry(globalRoot);
+    const entry = await registry.get(sessionId);
+    if (!entry) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Session not found" }));
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      sessionId: entry.sessionId,
+      projectName: entry.projectName,
+      status: entry.status,
+      agents: entry.agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        status: a.status,
+        currentTool: a.currentTool,
+        iterations: a.iterations,
+        toolCalls: a.toolCalls,
+        lastActivityAt: a.lastActivityAt
+      }))
+    }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+
+// src/server/file-handlers.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { atomicWrite } from "@wrongstack/core";
 
 // src/server/file-picker.ts
 var SKIP_DIRS = /* @__PURE__ */ new Set([
@@ -147,6 +249,193 @@ function rankFiles(paths, query, limit) {
   return scored.slice(0, limit).map((s) => s.path);
 }
 
+// src/server/ws-utils.ts
+import { randomBytes } from "crypto";
+import { WebSocket } from "ws";
+function send(ws, msg) {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+function broadcast(clients, msg) {
+  const data = JSON.stringify(msg);
+  for (const [ws] of clients) {
+    if (ws.readyState === WebSocket.OPEN) {
+      try {
+        ws.send(data);
+      } catch {
+      }
+    }
+  }
+}
+function sendResult(ws, success, message) {
+  send(ws, { type: "key.operation_result", payload: { success, message } });
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function generateAuthToken() {
+  return randomBytes(16).toString("hex");
+}
+
+// src/server/file-handlers.ts
+async function handleFilesTree(ws, msg, projectRoot) {
+  const payload = msg.payload;
+  const rawPath = payload?.path?.trim();
+  const treeRoot = rawPath && rawPath !== "." ? path2.resolve(projectRoot, rawPath) : projectRoot;
+  if (!treeRoot.startsWith(projectRoot + path2.sep) && treeRoot !== projectRoot) {
+    send(ws, {
+      type: "files.tree",
+      payload: { root: projectRoot, tree: [], error: "Path outside project root" }
+    });
+    return;
+  }
+  const pathPrefix = treeRoot === projectRoot ? "" : (path2.relative(projectRoot, treeRoot) + "/").replace(/\\/g, "/");
+  async function buildTree(dir, rel, depth) {
+    if (depth > 10) return [];
+    let entries = [];
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    const nodes = [];
+    for (const e of entries) {
+      if (isHiddenEntry(e.name)) continue;
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      const childAbs = path2.join(dir, e.name);
+      const childPath = pathPrefix + childRel;
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        const children = await buildTree(childAbs, childRel, depth + 1);
+        nodes.push({ name: e.name, path: childPath, type: "directory", children });
+      } else if (e.isFile()) {
+        nodes.push({ name: e.name, path: childPath, type: "file" });
+      }
+    }
+    return nodes;
+  }
+  try {
+    const tree = await buildTree(treeRoot, "", 0);
+    const rootLabel = treeRoot === projectRoot ? projectRoot : path2.relative(projectRoot, treeRoot) || ".";
+    send(ws, { type: "files.tree", payload: { root: rootLabel, tree } });
+  } catch (err) {
+    const rootLabel = treeRoot === projectRoot ? projectRoot : path2.relative(projectRoot, treeRoot) || ".";
+    send(ws, {
+      type: "files.tree",
+      payload: { root: rootLabel, tree: [], error: errMessage(err) }
+    });
+  }
+}
+async function handleFilesRead(ws, msg, projectRoot) {
+  const { filePath } = msg.payload;
+  const resolved = path2.resolve(projectRoot, filePath);
+  if (!resolved.startsWith(projectRoot + path2.sep) && resolved !== projectRoot) {
+    send(ws, { type: "files.read", payload: { filePath, content: "", error: "Forbidden" } });
+    return;
+  }
+  try {
+    const content = await fs2.readFile(resolved, "utf8");
+    send(ws, { type: "files.read", payload: { filePath, content } });
+  } catch (err) {
+    send(ws, {
+      type: "files.read",
+      payload: { filePath, content: "", error: errMessage(err) }
+    });
+  }
+}
+async function handleFilesWrite(ws, msg, projectRoot) {
+  const { filePath, content } = msg.payload;
+  const resolved = path2.resolve(projectRoot, filePath);
+  if (!resolved.startsWith(projectRoot + path2.sep) && resolved !== projectRoot) {
+    send(ws, { type: "files.written", payload: { filePath, success: false, error: "Forbidden" } });
+    return;
+  }
+  try {
+    await atomicWrite(resolved, content);
+    send(ws, { type: "files.written", payload: { filePath, success: true } });
+  } catch (err) {
+    send(ws, {
+      type: "files.written",
+      payload: { filePath, success: false, error: errMessage(err) }
+    });
+  }
+}
+async function handleFilesList(ws, msg, projectRoot) {
+  const payload = msg.payload ?? {};
+  const limit = payload.limit ?? 50;
+  const listRoot = payload.path ? path2.resolve(projectRoot, payload.path) : projectRoot;
+  if (!listRoot.startsWith(projectRoot + path2.sep) && listRoot !== projectRoot) {
+    send(ws, { type: "files.list", payload: { files: [] } });
+    return;
+  }
+  const results = [];
+  async function walk(dir, rel, depth) {
+    if (depth > 8 || results.length >= 600) return;
+    let entries = [];
+    try {
+      entries = await fs2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (results.length >= 600) return;
+      if (isHiddenEntry(e.name)) continue;
+      const childRel = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        await walk(path2.join(dir, e.name), childRel, depth + 1);
+      } else if (e.isFile()) {
+        results.push(childRel);
+      }
+    }
+  }
+  await walk(listRoot, "", 0);
+  send(ws, {
+    type: "files.list",
+    payload: { files: rankFiles(results, payload.query ?? "", limit) }
+  });
+}
+
+// src/server/memory-handlers.ts
+async function handleMemoryList(ws, memoryStore) {
+  try {
+    const text = await memoryStore.readAll();
+    send(ws, { type: "memory.list", payload: { text } });
+  } catch (err) {
+    send(ws, {
+      type: "memory.list",
+      payload: { text: "", error: errMessage(err) }
+    });
+  }
+}
+async function handleMemoryRemember(ws, msg, memoryStore) {
+  const { text, scope } = msg.payload;
+  try {
+    await memoryStore.remember(text, scope ?? "project-memory");
+    sendResult(ws, true, "Saved to memory");
+  } catch (err) {
+    sendResult(ws, false, errMessage(err));
+  }
+}
+async function handleMemoryForget(ws, msg, memoryStore) {
+  const { text, scope } = msg.payload;
+  try {
+    const removed = await memoryStore.forget(text, scope ?? "project-memory");
+    sendResult(
+      ws,
+      removed > 0,
+      removed > 0 ? `Removed ${removed} entr${removed === 1 ? "y" : "ies"}` : "No matching entries"
+    );
+  } catch (err) {
+    sendResult(ws, false, errMessage(err));
+  }
+}
+
 // src/server/index.ts
 import {
   Agent,
@@ -170,16 +459,20 @@ import {
   ProviderRegistry,
   TOKENS as TOKENS2,
   ToolRegistry,
-  atomicWrite as atomicWrite3,
+  atomicWrite as atomicWrite5,
   createDefaultPipelines,
+  createSessionEventBridge,
+  resolveSessionLoggingConfig,
   DEFAULT_CONTEXT_WINDOW_MODE_ID,
   DEFAULT_SESSION_PRUNE_DAYS,
   DEFAULT_TOOLS_CONFIG,
-  listContextWindowModes,
   repairToolUseAdjacency,
-  resolveContextWindowPolicy
+  resolveContextWindowPolicy,
+  enhanceUserPrompt,
+  recentTextTurns
 } 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 { WebSocketServer } from "ws";
@@ -1423,19 +1716,112 @@ var WorktreeWebSocketHandler = class {
   }
 };
 
+// src/server/mailbox-handlers.ts
+import * as path3 from "path";
+import { GlobalMailbox } from "@wrongstack/core";
+function resolveProjectDir(projectRoot, globalRoot) {
+  const { createHash } = __require("crypto");
+  const hash = createHash("sha256").update(path3.resolve(projectRoot)).digest("hex").slice(0, 6);
+  const slug = path3.basename(projectRoot).toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 40) || "project";
+  return path3.join(globalRoot, "projects", `${slug}-${hash}`);
+}
+async function handleMailboxMessages(ws, deps, payload) {
+  try {
+    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const mb = new GlobalMailbox(dir);
+    const messages = await mb.query({
+      limit: payload?.limit ?? 30,
+      to: payload?.agentId,
+      unreadBy: payload?.unreadOnly ? payload.agentId : void 0
+    });
+    send(ws, {
+      type: "mailbox.messages",
+      payload: {
+        messages: messages.map((m) => ({
+          id: m.id,
+          from: m.from,
+          to: m.to,
+          type: m.type,
+          subject: m.subject,
+          body: m.body,
+          priority: m.priority,
+          readBy: m.readBy,
+          readByCount: Object.keys(m.readBy).length,
+          completed: m.completed,
+          completedBy: m.completedBy,
+          outcome: m.outcome,
+          timestamp: m.timestamp,
+          replyTo: m.replyTo,
+          senderSessionId: m.senderSessionId
+        }))
+      }
+    });
+  } catch (err) {
+    send(ws, { type: "mailbox.messages", payload: { messages: [], error: errMessage(err) } });
+  }
+}
+async function handleMailboxAgents(ws, deps, payload) {
+  try {
+    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const mb = new GlobalMailbox(dir);
+    const agents = payload?.onlineOnly ? await mb.getOnlineAgents() : await mb.getAgentStatuses();
+    send(ws, {
+      type: "mailbox.agents",
+      payload: {
+        agents: agents.map((a) => ({
+          agentId: a.agentId,
+          name: a.name,
+          role: a.role,
+          sessionId: a.sessionId,
+          status: a.status,
+          currentTool: a.currentTool,
+          currentTask: a.currentTask,
+          iterations: a.iterations,
+          toolCalls: a.toolCalls,
+          lastSeenAt: a.lastSeenAt,
+          online: a.online,
+          pid: a.pid,
+          source: a.source
+        }))
+      }
+    });
+  } catch (err) {
+    send(ws, { type: "mailbox.agents", payload: { agents: [], error: errMessage(err) } });
+  }
+}
+async function handleMailboxClear(ws, deps) {
+  try {
+    const dir = resolveProjectDir(deps.projectRoot, deps.globalRoot);
+    const mb = new GlobalMailbox(dir);
+    await mb.clearAll();
+    send(ws, { type: "mailbox.cleared", payload: {} });
+  } catch (err) {
+    send(ws, { type: "mailbox.cleared", payload: { error: errMessage(err) } });
+  }
+}
+
 // src/server/ws-auth.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 import { timingSafeEqual } from "crypto";
 function isLoopbackHostname(hostname) {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
 }
+function isTrustedLoopbackOrigin(origin) {
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
 function isLoopbackBind(wsHost) {
   return wsHost === "127.0.0.1" || wsHost === "::1" || wsHost === "localhost";
 }
 function tokenMatches(provided, expected) {
   if (!provided) return false;
-  const a = Buffer.from(provided);
-  const b = Buffer.from(expected);
+  const a = Buffer2.from(provided);
+  const b = Buffer2.from(expected);
   if (a.length !== b.length) return false;
   return timingSafeEqual(a, b);
 }
@@ -1467,7 +1853,12 @@ function verifyClient(input) {
   }
   try {
     const { hostname } = new URL(origin);
-    if (isLoopbackHostname(hostname)) return true;
+    if (isLoopbackHostname(hostname)) {
+      if (wsHost === "0.0.0.0" && !isTrustedLoopbackOrigin(origin)) {
+        return false;
+      }
+      return true;
+    }
     return tokenOk;
   } catch {
     return false;
@@ -1512,14 +1903,14 @@ function registerShutdownHandlers(res) {
 
 // src/server/instance-registry.ts
 import * as os from "os";
-import * as path2 from "path";
-import * as fs2 from "fs/promises";
-import { atomicWrite } from "@wrongstack/core";
+import * as path4 from "path";
+import * as fs3 from "fs/promises";
+import { atomicWrite as atomicWrite2 } from "@wrongstack/core";
 function defaultBaseDir() {
-  return path2.join(os.homedir(), ".wrongstack");
+  return path4.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path2.join(baseDir, "webui-instances.json");
+  return path4.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -1532,7 +1923,7 @@ function isPidAlive(pid) {
 }
 async function load(file) {
   try {
-    const raw = await fs2.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;
@@ -1542,7 +1933,7 @@ async function load(file) {
   return { version: 1, instances: [] };
 }
 async function save(file, instances) {
-  await atomicWrite(file, `${JSON.stringify({ version: 1, instances }, null, 2)}
+  await atomicWrite2(file, `${JSON.stringify({ version: 1, instances }, null, 2)}
 `, {
     mode: 384
   });
@@ -1591,16 +1982,16 @@ function formatInstances(instances) {
 // src/server/port-utils.ts
 import * as net from "net";
 function isPortFree(host, port) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve5) => {
     const srv = net.createServer();
-    srv.once("error", () => resolve3(false));
+    srv.once("error", () => resolve5(false));
     srv.once("listening", () => {
-      srv.close(() => resolve3(true));
+      srv.close(() => resolve5(true));
     });
     try {
       srv.listen(port, host);
     } catch {
-      resolve3(false);
+      resolve5(false);
     }
   });
 }
@@ -1676,15 +2067,15 @@ function computeUsageCost(usage, rates) {
 }
 
 // src/server/provider-config-io.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
-import { atomicWrite as atomicWrite2 } from "@wrongstack/core";
+import * as fs4 from "fs/promises";
+import * as path5 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 fs3.readFile(configPath, "utf8");
+    raw = await fs4.readFile(configPath, "utf8");
   } catch {
     return {};
   }
@@ -1701,7 +2092,7 @@ async function saveProviders(configPath, vault, providers) {
   let raw;
   let fileExists = true;
   try {
-    raw = await fs3.readFile(configPath, "utf8");
+    raw = await fs4.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(
@@ -1726,7 +2117,7 @@ async function saveProviders(configPath, vault, providers) {
   }
   parsed.providers = providers;
   const encrypted = encryptConfigSecrets(parsed, vault);
-  await atomicWrite2(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+  await atomicWrite3(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
 }
 
 // src/server/provider-keys.ts
@@ -1825,38 +2216,9 @@ function removeProvider(providers, providerId) {
   return { ok: true, message: `Provider "${providerId}" removed` };
 }
 
-// src/server/ws-utils.ts
-import { randomBytes } from "crypto";
-import { WebSocket } from "ws";
-function send(ws, msg) {
-  if (ws.readyState === WebSocket.OPEN) {
-    ws.send(JSON.stringify(msg));
-  }
-}
-function broadcast(clients, msg) {
-  const data = JSON.stringify(msg);
-  for (const [ws] of clients) {
-    if (ws.readyState === WebSocket.OPEN) {
-      try {
-        ws.send(data);
-      } catch {
-      }
-    }
-  }
-}
-function sendResult(ws, success, message) {
-  send(ws, { type: "key.operation_result", payload: { success, message } });
-}
-function errMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function generateAuthToken() {
-  return randomBytes(16).toString("hex");
-}
-
 // src/server/provider-handlers.ts
 function createProviderHandlers(deps) {
-  const { globalConfigPath, vault } = deps;
+  const { globalConfigPath, vault, broadcast: broadcast2, clients } = deps;
   let configWriteLock = deps.getConfigWriteLock();
   async function loadConfigProviders() {
     return loadSavedProviders(globalConfigPath, vault);
@@ -1864,7 +2226,12 @@ function createProviderHandlers(deps) {
   async function saveConfigProviders(providers) {
     const next = configWriteLock.then(() => saveProviders(globalConfigPath, vault, providers)).catch((err) => {
       const msg = err instanceof Error ? err.message : String(err);
-      console.error(`[ProviderHandlers] saveProviders failed: ${msg}`);
+      console.error(JSON.stringify({
+        level: "error",
+        event: "webui.provider_save_failed",
+        message: msg,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
     configWriteLock = next;
     deps.setConfigWriteLock(next);
@@ -1906,6 +2273,28 @@ function createProviderHandlers(deps) {
       const result = addProvider(providers, payload, (/* @__PURE__ */ new Date()).toISOString());
       if (result.ok) await saveConfigProviders(providers);
       sendResult(ws, result.ok, result.message);
+      if (result.ok) {
+        console.log(`[WebUI] Provider "${payload.id}" added via provider.add`);
+        broadcast2(clients, {
+          type: "providers.saved",
+          payload: {
+            providers: Object.entries(providers).map(([id, cfg]) => {
+              const keys = normalizeKeys(cfg);
+              return {
+                id,
+                family: cfg.family ?? id,
+                baseUrl: cfg.baseUrl,
+                apiKeys: keys.map((k) => ({
+                  label: k.label,
+                  maskedKey: maskedKey(k.apiKey),
+                  isActive: k.label === cfg.activeKey,
+                  createdAt: k.createdAt
+                }))
+              };
+            })
+          }
+        });
+      }
     } catch (err) {
       sendResult(ws, false, errMessage(err));
     }
@@ -1924,12 +2313,14 @@ function createProviderHandlers(deps) {
 }
 
 // src/server/setup-events.ts
+import * as path6 from "path";
 function setupEvents(deps) {
-  const { events, broadcast: broadcast2, clients, config, context, pendingConfirms } = deps;
+  const { events, broadcast: broadcast2, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge } = deps;
   events.on("iteration.started", (e) => {
+    const maxIt = typeof context.meta["maxIterations"] === "number" ? context.meta["maxIterations"] : config.tools?.maxIterations ?? 100;
     broadcast2(clients, {
       type: "iteration.started",
-      payload: { index: e.index, maxIterations: config.tools?.maxIterations ?? 100 }
+      payload: { index: e.index, maxIterations: maxIt }
     });
   });
   events.on("provider.text_delta", (e) => {
@@ -1943,19 +2334,70 @@ function setupEvents(deps) {
       type: "tool.started",
       payload: { id: e.id, name: e.name, input: e.input, messageId: `tool_${e.id}` }
     });
+    sessionBridge?.append({
+      type: "tool_call_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id,
+      input: e.input
+    }).catch(() => {
+    });
   });
   events.on("tool.progress", (e) => {
     broadcast2(clients, {
       type: "tool.progress",
       payload: { id: e.id, name: e.name, eventType: e.event.type, text: e.event.text }
     });
+    sessionBridge?.append({
+      type: "tool_progress",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id,
+      event: { type: e.event.type, text: e.event.text, data: e.event.data }
+    }).catch(() => {
+    });
   });
   events.on("tool.executed", (e) => {
     broadcast2(clients, {
       type: "tool.executed",
       payload: { id: e.id, name: e.name, durationMs: e.durationMs, ok: e.ok, input: e.input, output: e.output }
     });
+    sessionBridge?.append({
+      type: "tool_call_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      name: e.name,
+      id: e.id ?? "",
+      durationMs: e.durationMs,
+      outputSize: e.outputBytes ?? 0,
+      ok: e.ok,
+      outputBytes: e.outputBytes,
+      outputTokens: e.outputTokens,
+      outputLines: e.outputLines
+    }).catch(() => {
+    });
     broadcast2(clients, { type: "todos.updated", payload: { todos: [...context.todos] } });
+    if (e.name === "task" || e.name === "plan" || e.name === "todo") {
+      void (async () => {
+        try {
+          const taskPath = context.meta["task.path"];
+          if (typeof taskPath === "string" && taskPath) {
+            const { loadTasks } = await import("@wrongstack/core");
+            const file = await loadTasks(taskPath);
+            broadcast2(clients, { type: "tasks.updated", payload: { tasks: file?.tasks ?? [] } });
+          }
+        } catch {
+        }
+        try {
+          const planPath = context.meta["plan.path"];
+          if (typeof planPath === "string" && planPath) {
+            const { loadPlan } = await import("@wrongstack/core");
+            const plan = await loadPlan(planPath);
+            broadcast2(clients, { type: "plan.updated", payload: { plan: plan ?? { version: 1, sessionId: context.session?.id ?? "", updatedAt: (/* @__PURE__ */ new Date()).toISOString(), items: [] } } });
+          }
+        } catch {
+        }
+      })();
+    }
   });
   events.on("provider.response", (e) => {
     broadcast2(clients, { type: "provider.response", payload: { usage: e.usage, stopReason: e.stopReason, messageId: "current" } });
@@ -1970,32 +2412,274 @@ function setupEvents(deps) {
   });
   events.on("error", (e) => {
     broadcast2(clients, { type: "error", payload: { phase: e.phase, message: e.err instanceof Error ? e.err.message : String(e.err) } });
+    sessionBridge?.append({
+      type: "error",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      message: e.err instanceof Error ? e.err.message : String(e.err),
+      phase: e.phase
+    }).catch(() => {
+    });
+  });
+  events.on("provider.retry", (e) => {
+    sessionBridge?.append({
+      type: "provider_retry",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      providerId: e.providerId,
+      attempt: e.attempt,
+      delayMs: e.delayMs,
+      status: e.status,
+      description: e.description
+    }).catch(() => {
+    });
+  });
+  events.on("provider.error", (e) => {
+    sessionBridge?.append({
+      type: "provider_error",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      providerId: e.providerId,
+      status: e.status,
+      description: e.description,
+      retryable: e.retryable
+    }).catch(() => {
+    });
+  });
+  events.onPattern("mailbox.received", (_e, payload) => {
+    broadcast2(clients, { type: "mailbox.received", payload });
   });
-  const forwardSubagent = (kind, payload) => broadcast2(clients, { type: "subagent.event", payload: { kind, ...payload } });
+  events.onPattern("mailbox.agent_registered", (_e, payload) => {
+    broadcast2(clients, { type: "mailbox.agent_registered", payload });
+  });
+  const forwardSubagent = (kind, payload) => broadcast2(clients, { type: "subagent.event", payload: { kind, sessionId: context.session.id, ...payload } });
   events.on("subagent.spawned", (e) => forwardSubagent("spawned", { subagentId: e.subagentId, taskId: e.taskId, name: e.name, provider: e.provider, model: e.model, description: e.description }));
   events.on("subagent.task_started", (e) => forwardSubagent("task_started", { subagentId: e.subagentId, taskId: e.taskId, description: e.description }));
   events.on("subagent.tool_executed", (e) => forwardSubagent("tool_executed", { subagentId: e.subagentId, toolName: e.name, durationMs: e.durationMs, ok: e.ok }));
-  events.on("subagent.iteration_summary", (e) => forwardSubagent("iteration_summary", { subagentId: e.subagentId, iteration: e.iteration, toolCalls: e.toolCalls, costUsd: e.costUsd, currentTool: e.currentTool }));
+  events.on("subagent.iteration_summary", (e) => forwardSubagent("iteration_summary", { subagentId: e.subagentId, iteration: e.iteration, toolCalls: e.toolCalls, costUsd: e.costUsd, currentTool: e.currentTool, partialText: e.partialText }));
   events.on("subagent.budget_extended", (e) => forwardSubagent("budget_extended", { subagentId: e.subagentId, totalExtensions: e.totalExtensions }));
   events.on("subagent.ctx_pct", (e) => forwardSubagent("ctx_pct", { subagentId: e.subagentId, load: e.load, tokens: e.tokens, maxContext: e.maxContext }));
-  events.on("subagent.task_completed", (e) => forwardSubagent("task_completed", { subagentId: e.subagentId, status: e.status, iterations: e.iterations, toolCalls: e.toolCalls, error: e.error ? { kind: e.error.kind, message: e.error.message } : void 0 }));
+  events.on("subagent.task_completed", (e) => forwardSubagent("task_completed", { subagentId: e.subagentId, status: e.status, iterations: e.iterations, toolCalls: e.toolCalls, finalText: e.finalText, error: e.error ? { kind: e.error.kind, message: e.error.message } : void 0 }));
+  let leaderSpawned = false;
+  events.on("iteration.started", () => {
+    if (!leaderSpawned) {
+      leaderSpawned = true;
+      const provider = context.provider?.id ?? "unknown";
+      forwardSubagent("spawned", {
+        subagentId: "leader",
+        name: "LEADER",
+        provider,
+        model: context.model,
+        description: `Main agent session (${context.session.id})`
+      });
+    }
+  });
+  events.on("tool.executed", (e) => {
+    forwardSubagent("tool_executed", {
+      subagentId: "leader",
+      toolName: e.name,
+      durationMs: e.durationMs,
+      ok: e.ok
+    });
+  });
+  events.on("provider.response", (e) => {
+    if (e.usage?.input != null) {
+      const maxCtx = context.provider.capabilities.maxContext;
+      const pct = maxCtx > 0 ? e.usage.input / maxCtx : 0;
+      const costUsd = context.tokenCounter.estimateCost().total;
+      forwardSubagent("ctx_pct", {
+        subagentId: "leader",
+        load: pct,
+        tokens: e.usage.input,
+        maxContext: maxCtx,
+        costUsd
+      });
+    }
+  });
+  events.on("iteration.completed", () => {
+    if (!leaderSpawned) {
+      leaderSpawned = true;
+      const provider = context.provider?.id ?? "unknown";
+      forwardSubagent("spawned", {
+        subagentId: "leader",
+        name: "LEADER",
+        provider,
+        model: context.model,
+        description: `Main agent session (${context.session.id})`
+      });
+    }
+  });
+  events.onPattern("mailbox.*", (eventName, payload) => {
+    broadcast2(clients, { type: "mailbox.event", payload: { event: eventName, ...payload } });
+  });
+  events.onPattern("brain.*", (eventName, payload) => {
+    broadcast2(clients, { type: "brain.event", payload: { event: eventName, ...payload } });
+  });
+  const globalRoot = globalConfigPath ? path6.dirname(globalConfigPath) : void 0;
+  if (globalRoot) {
+    const statusInterval = setInterval(async () => {
+      try {
+        const { SessionRegistry } = await import("@wrongstack/core");
+        const registry = new SessionRegistry(globalRoot);
+        const sessions = await registry.list();
+        const live = sessions.filter((s) => s.status !== "stale").map((s) => ({
+          sessionId: s.sessionId,
+          projectName: s.projectName,
+          projectSlug: s.projectSlug,
+          projectRoot: s.projectRoot,
+          workingDir: s.workingDir,
+          gitBranch: s.gitBranch,
+          status: s.status,
+          pid: s.pid,
+          startedAt: s.startedAt,
+          agentCount: s.agentCount,
+          agents: (s.agents ?? []).map((a) => ({
+            id: a.id,
+            name: a.name,
+            status: a.status,
+            currentTool: a.currentTool,
+            iterations: a.iterations,
+            toolCalls: a.toolCalls,
+            lastActivityAt: a.lastActivityAt
+          }))
+        }));
+        broadcast2(clients, { type: "sessions.status_update", payload: { sessions: live } });
+      } catch {
+      }
+    }, 5e3);
+    if (statusInterval.unref) statusInterval.unref();
+  }
 }
 
-// src/server/token-estimator.ts
-function estimateTokens(s) {
-  return Math.ceil(s.length / 4);
-}
-function stringifyContent(c) {
-  if (typeof c === "string") return c;
-  try {
-    return JSON.stringify(c);
-  } catch {
-    return String(c);
-  }
+// src/server/custom-context-modes.ts
+import { listContextWindowModes, atomicWrite as atomicWrite4 } from "@wrongstack/core";
+import * as fs5 from "fs/promises";
+import * as path7 from "path";
+var STORE_FILENAME = "custom-context-modes.json";
+function storePath(wrongstackDir) {
+  return path7.join(wrongstackDir, STORE_FILENAME);
 }
-function messageTokens(content) {
-  if (typeof content === "string") return estimateTokens(content);
-  if (!Array.isArray(content)) return 0;
+var BUILTIN_IDS = /* @__PURE__ */ new Set(["balanced", "frugal", "deep", "archival"]);
+function createCustomModeStore(wrongstackDir) {
+  const modes = /* @__PURE__ */ new Map();
+  const load2 = async () => {
+    modes.clear();
+    try {
+      const raw = await fs5.readFile(storePath(wrongstackDir), "utf8");
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed.modes)) {
+        for (const m of parsed.modes) {
+          if (m.id && !BUILTIN_IDS.has(m.id)) {
+            modes.set(m.id, { ...m, custom: true });
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  const save2 = async () => {
+    const arr = [...modes.values()];
+    const json = JSON.stringify({ modes: arr }, null, 2);
+    await atomicWrite4(storePath(wrongstackDir), json);
+  };
+  const create = (mode) => {
+    if (!mode.id || typeof mode.id !== "string") {
+      return { ok: false, error: "id is required" };
+    }
+    if (BUILTIN_IDS.has(mode.id)) {
+      return { ok: false, error: `Cannot override built-in mode "${mode.id}"` };
+    }
+    if (modes.has(mode.id)) {
+      return { ok: false, error: `Mode "${mode.id}" already exists` };
+    }
+    if (!mode.name) {
+      return { ok: false, error: "name is required" };
+    }
+    const entry = {
+      id: mode.id,
+      name: mode.name,
+      description: mode.description || "",
+      thresholds: {
+        warn: mode.thresholds?.warn ?? 0.6,
+        soft: mode.thresholds?.soft ?? 0.75,
+        hard: mode.thresholds?.hard ?? 0.9
+      },
+      aggressiveOn: mode.aggressiveOn || "soft",
+      preserveK: mode.preserveK ?? 10,
+      eliseThreshold: mode.eliseThreshold ?? 2e3,
+      targetLoad: mode.targetLoad ?? 0.65,
+      custom: true
+    };
+    modes.set(mode.id, entry);
+    void save2();
+    return { ok: true };
+  };
+  const update = (id, patch) => {
+    if (BUILTIN_IDS.has(id)) {
+      return { ok: false, error: `Cannot modify built-in mode "${id}"` };
+    }
+    const existing = modes.get(id);
+    if (!existing) {
+      return { ok: false, error: `Mode "${id}" not found` };
+    }
+    const next = { ...existing };
+    if (patch.name !== void 0) next.name = patch.name;
+    if (patch.description !== void 0) next.description = patch.description;
+    if (patch.thresholds) {
+      next.thresholds = {
+        warn: patch.thresholds.warn ?? existing.thresholds.warn,
+        soft: patch.thresholds.soft ?? existing.thresholds.soft,
+        hard: patch.thresholds.hard ?? existing.thresholds.hard
+      };
+    }
+    if (patch.preserveK !== void 0) next.preserveK = patch.preserveK;
+    if (patch.eliseThreshold !== void 0) next.eliseThreshold = patch.eliseThreshold;
+    if (patch.targetLoad !== void 0) next.targetLoad = patch.targetLoad;
+    if (patch.aggressiveOn !== void 0) next.aggressiveOn = patch.aggressiveOn;
+    modes.set(id, next);
+    void save2();
+    return { ok: true };
+  };
+  const remove = (id) => {
+    if (BUILTIN_IDS.has(id)) {
+      return { ok: false, error: `Cannot delete built-in mode "${id}"` };
+    }
+    if (!modes.delete(id)) {
+      return { ok: false, error: `Mode "${id}" not found` };
+    }
+    void save2();
+    return { ok: true };
+  };
+  const list = () => {
+    const builtins = listContextWindowModes().map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description,
+      thresholds: { ...m.thresholds },
+      aggressiveOn: m.aggressiveOn,
+      preserveK: m.preserveK,
+      eliseThreshold: m.eliseThreshold,
+      targetLoad: m.targetLoad,
+      custom: false
+    }));
+    const custom = [...modes.values()];
+    return [...builtins, ...custom];
+  };
+  return { modes, load: load2, save: save2, create, update, remove, list };
+}
+
+// src/server/token-estimator.ts
+function estimateTokens(s) {
+  return Math.ceil(s.length / 4);
+}
+function stringifyContent(c) {
+  if (typeof c === "string") return c;
+  try {
+    return JSON.stringify(c);
+  } catch {
+    return String(c);
+  }
+}
+function messageTokens(content) {
+  if (typeof content === "string") return estimateTokens(content);
+  if (!Array.isArray(content)) return 0;
   let tk = 0;
   for (const b of content) {
     if (b.type === "text") tk += estimateTokens(b.text ?? "");
@@ -2050,16 +2734,32 @@ async function startWebUI(opts = {}) {
     httpPort = await findFreePort(wsHost, requestedHttpPort);
     wsPort = await findFreePort(wsHost, requestedWsPort, { exclude: /* @__PURE__ */ new Set([httpPort]) });
     if (httpPort !== requestedHttpPort) {
-      console.warn(`[WebUI] HTTP port ${requestedHttpPort} in use \u2192 using ${httpPort}`);
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "webui.port_reassigned",
+        protocol: "HTTP",
+        requested: requestedHttpPort,
+        assigned: httpPort,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     }
     if (wsPort !== requestedWsPort) {
-      console.warn(`[WebUI] WS port ${requestedWsPort} in use \u2192 using ${wsPort}`);
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "webui.port_reassigned",
+        protocol: "WS",
+        requested: requestedWsPort,
+        assigned: wsPort,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     }
   }
   console.log("[WebUI] Starting backend services...");
   const boot = await bootConfig();
-  const { config: baseConfig, vault, globalConfigPath, projectRoot, wpaths, logger } = boot;
+  const { config: baseConfig, vault, globalConfigPath, wpaths, logger } = boot;
   let config = baseConfig;
+  let projectRoot = boot.projectRoot;
+  let workingDir = projectRoot;
   let configWriteLock = Promise.resolve();
   console.log("[WebUI] Config loaded:", config.provider ?? "(none)", "/", config.model ?? "(none)");
   if (!config.provider && config.providers && typeof config.providers === "object" && config.providers !== null && !Array.isArray(config.providers) && Object.keys(config.providers).length > 0) {
@@ -2083,7 +2783,12 @@ async function startWebUI(opts = {}) {
     for (const f of factories) providerRegistry.register(f);
     console.log("[WebUI] Provider registry loaded:", providerRegistry.list().length, "providers");
   } catch (err) {
-    console.warn("[WebUI] Failed to load provider registry:", err);
+    console.warn(JSON.stringify({
+      level: "warn",
+      event: "webui.provider_registry_load_failed",
+      message: err instanceof Error ? err.message : String(err),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
   }
   const toolRegistry = new ToolRegistry();
   toolRegistry.registerAllOrThrow([...builtinToolsPack.tools ?? []], builtinToolsPack.name);
@@ -2094,10 +2799,13 @@ async function startWebUI(opts = {}) {
     toolRegistry.register(searchMemoryTool(memoryStore));
     toolRegistry.register(relatedMemoryTool(memoryStore));
   }
-  console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const events = new EventBus();
   events.setLogger(logger);
-  const sessionStore = new DefaultSessionStore2({ dir: wpaths.projectSessions });
+  toolRegistry.register(makeMailboxTool({ projectDir: wpaths.projectDir, events }));
+  toolRegistry.register(makeMailSendTool({ projectDir: wpaths.projectDir, events }));
+  toolRegistry.register(makeMailInboxTool({ projectDir: wpaths.projectDir, events }));
+  console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
+  let sessionStore = new DefaultSessionStore2({ dir: wpaths.projectSessions });
   sessionStore.prune(DEFAULT_SESSION_PRUNE_DAYS).then((count) => {
     if (count > 0) logger.info(`Pruned ${count} old session${count === 1 ? "" : "s"}.`);
   }).catch(() => void 0);
@@ -2111,6 +2819,42 @@ async function startWebUI(opts = {}) {
   });
   let sessionStartedAt = Date.now();
   console.log("[WebUI] Session created:", session.id);
+  try {
+    await touchProjectEntry(projectRoot, workingDir);
+  } catch {
+  }
+  let statusTracker;
+  try {
+    const registry = getSessionRegistry(wpaths.globalRoot);
+    await registry.register({
+      sessionId: session.id,
+      projectSlug: wpaths.projectSlug,
+      projectRoot,
+      projectName: path8.basename(projectRoot),
+      workingDir,
+      pid: process.pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    statusTracker = new AgentStatusTracker({ events, registry });
+    statusTracker.start();
+    const stopTracking = async () => {
+      try {
+        await registry.markClosing();
+        statusTracker?.stop();
+      } catch {
+      }
+    };
+    process.once("beforeExit", () => {
+      void stopTracking();
+    });
+    process.once("SIGINT", () => {
+      void stopTracking();
+    });
+    process.once("SIGTERM", () => {
+      void stopTracking();
+    });
+  } catch {
+  }
   const tokenCounter = new DefaultTokenCounter2({
     registry: modelsRegistry,
     providerId: config.provider
@@ -2119,6 +2863,13 @@ async function startWebUI(opts = {}) {
   const activeMode = await modeStore.getActiveMode();
   let modeId = activeMode?.id ?? "default";
   const modePrompt = activeMode?.prompt ?? "";
+  const customModeStore = createCustomModeStore(wpaths.configDir);
+  await customModeStore.load();
+  console.log(
+    "[WebUI] Custom context modes loaded:",
+    customModeStore.list().filter((m) => m.custom).length,
+    "custom"
+  );
   const resolvedModel = await modelsRegistry.getModel(config.provider, config.model);
   const modelCapabilities = resolvedModel?.capabilities ? {
     maxContextTokens: resolvedModel.capabilities.maxContext,
@@ -2135,12 +2886,19 @@ async function startWebUI(opts = {}) {
     modePrompt,
     modelCapabilities
   });
+  let onlineAgents = [];
+  try {
+    const systemMailbox = new GlobalMailbox2(wpaths.projectDir);
+    onlineAgents = await systemMailbox.getAgentStatuses();
+  } catch {
+  }
   const systemPrompt = await systemPromptBuilder.build({
     cwd: projectRoot,
     projectRoot,
     tools: toolRegistry.list(),
     provider: config.provider,
-    model: config.model
+    model: config.model,
+    onlineAgents
   });
   let provider;
   if (!needsProvider) {
@@ -2157,7 +2915,12 @@ async function startWebUI(opts = {}) {
         provider = makeProviderFromConfig(config.provider, cfgWithType);
       }
     } catch (err) {
-      console.error("[WebUI] Failed to create provider:", err);
+      console.error(JSON.stringify({
+        level: "error",
+        event: "webui.provider_create_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
       throw err;
     }
   } else {
@@ -2174,7 +2937,12 @@ async function startWebUI(opts = {}) {
         });
         console.log("[WebUI] Using saved provider:", firstKey);
       } catch (err) {
-        console.error("[WebUI] Could not create provider stub:", err);
+        console.error(JSON.stringify({
+          level: "error",
+          event: "webui.provider_stub_create_failed",
+          message: err instanceof Error ? err.message : String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
         throw err;
       }
     } else {
@@ -2189,13 +2957,160 @@ async function startWebUI(opts = {}) {
     session,
     signal: new AbortController().signal,
     tokenCounter,
-    cwd: projectRoot,
+    cwd: workingDir,
     projectRoot,
     model: config.model
   });
   const initialContextPolicy = resolveContextWindowPolicy(config.context);
   context.meta["contextWindowMode"] = initialContextPolicy.id;
   context.meta["contextWindowPolicy"] = initialContextPolicy;
+  {
+    const autonomyCfg = config.autonomy ?? {};
+    const rawMode = autonomyCfg["defaultMode"];
+    context.meta["autonomy"] = rawMode === "suggest" || rawMode === "auto" ? rawMode : "off";
+    context.meta["autonomyDelayMs"] = autonomyCfg["autoProceedDelayMs"] ?? 45e3;
+    context.meta["autoProceedMaxIterations"] = autonomyCfg["autoProceedMaxIterations"] ?? 50;
+    context.meta["yolo"] = autonomyCfg["yolo"] ?? config.yolo ?? false;
+    context.meta["chime"] = autonomyCfg["chime"] ?? false;
+    context.meta["confirmExit"] = autonomyCfg["confirmExit"] !== false;
+    context.meta["streamFleet"] = autonomyCfg["streamFleet"] !== false;
+    context.meta["enhanceEnabled"] = autonomyCfg["enhance"] ?? true;
+    context.meta["enhanceDelayMs"] = autonomyCfg["enhanceDelayMs"] ?? 6e4;
+    context.meta["enhanceLanguage"] = autonomyCfg["enhanceLanguage"] ?? "original";
+    context.meta["nextPrediction"] = config.nextPrediction ?? false;
+    context.meta["featureMcp"] = config.features.mcp !== false;
+    context.meta["featurePlugins"] = config.features.plugins !== false;
+    context.meta["featureMemory"] = config.features.memory !== false;
+    context.meta["featureSkills"] = config.features.skills !== false;
+    context.meta["featureModelsRegistry"] = config.features.modelsRegistry !== false;
+    context.meta["indexOnStart"] = config.indexing?.onSessionStart !== false;
+    context.meta["contextAutoCompact"] = config.context?.autoCompact !== false;
+    context.meta["contextStrategy"] = config.context?.strategy ?? "hybrid";
+    context.meta["logLevel"] = config.log?.level ?? "info";
+    context.meta["auditLevel"] = config.session?.auditLevel ?? "standard";
+    context.meta["maxIterations"] = config.tools?.maxIterations ?? 500;
+  }
+  const PREF_KEYS = [
+    "autonomy",
+    "autonomyDelayMs",
+    "autoProceedMaxIterations",
+    "yolo",
+    "maxIterations",
+    "chime",
+    "confirmExit",
+    "streamFleet",
+    "nextPrediction",
+    "enhanceEnabled",
+    "enhanceDelayMs",
+    "enhanceLanguage",
+    "featureMcp",
+    "featurePlugins",
+    "featureMemory",
+    "featureSkills",
+    "featureModelsRegistry",
+    "indexOnStart",
+    "contextAutoCompact",
+    "contextStrategy",
+    "logLevel",
+    "auditLevel"
+  ];
+  const prefSnapshot = () => {
+    const snapshot = {};
+    for (const k of PREF_KEYS) {
+      if (k in context.meta) snapshot[k] = context.meta[k];
+    }
+    return snapshot;
+  };
+  const persistPrefsToConfig = async (payload) => {
+    const write = async () => {
+      let raw;
+      try {
+        raw = await fs6.readFile(globalConfigPath, "utf8");
+      } catch {
+        raw = "{}";
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        logger.warn(`prefs: refusing to overwrite corrupt config at ${globalConfigPath}`);
+        return;
+      }
+      const decrypted = decryptConfigSecrets2(parsed, vault);
+      const autonomyCfg = decrypted.autonomy ?? {};
+      let autonomyTouched = false;
+      const setAutonomy = (key, val) => {
+        autonomyCfg[key] = val;
+        autonomyTouched = true;
+      };
+      if (typeof payload["autonomy"] === "string" && ["off", "suggest", "auto"].includes(payload["autonomy"])) {
+        setAutonomy("defaultMode", payload["autonomy"]);
+      }
+      if (typeof payload["autonomyDelayMs"] === "number") setAutonomy("autoProceedDelayMs", payload["autonomyDelayMs"]);
+      if (typeof payload["autoProceedMaxIterations"] === "number") setAutonomy("autoProceedMaxIterations", payload["autoProceedMaxIterations"]);
+      if (typeof payload["yolo"] === "boolean") setAutonomy("yolo", payload["yolo"]);
+      if (typeof payload["chime"] === "boolean") setAutonomy("chime", payload["chime"]);
+      if (typeof payload["confirmExit"] === "boolean") setAutonomy("confirmExit", payload["confirmExit"]);
+      if (typeof payload["streamFleet"] === "boolean") setAutonomy("streamFleet", payload["streamFleet"]);
+      if (typeof payload["enhanceEnabled"] === "boolean") setAutonomy("enhance", payload["enhanceEnabled"]);
+      if (typeof payload["enhanceDelayMs"] === "number") setAutonomy("enhanceDelayMs", payload["enhanceDelayMs"]);
+      if (typeof payload["enhanceLanguage"] === "string") setAutonomy("enhanceLanguage", payload["enhanceLanguage"]);
+      if (autonomyTouched) decrypted.autonomy = autonomyCfg;
+      if (typeof payload["nextPrediction"] === "boolean") decrypted.nextPrediction = payload["nextPrediction"];
+      const FEATURE_MAP = {
+        featureMcp: "mcp",
+        featurePlugins: "plugins",
+        featureMemory: "memory",
+        featureSkills: "skills",
+        featureModelsRegistry: "modelsRegistry"
+      };
+      for (const [prefKey, cfgKey] of Object.entries(FEATURE_MAP)) {
+        if (typeof payload[prefKey] === "boolean") {
+          const feats = decrypted.features ?? {};
+          feats[cfgKey] = payload[prefKey];
+          decrypted.features = feats;
+        }
+      }
+      if (typeof payload["contextAutoCompact"] === "boolean" || typeof payload["contextStrategy"] === "string") {
+        const ctxCfg = decrypted.context ?? {};
+        if (typeof payload["contextAutoCompact"] === "boolean") ctxCfg.autoCompact = payload["contextAutoCompact"];
+        if (typeof payload["contextStrategy"] === "string") ctxCfg.strategy = payload["contextStrategy"];
+        decrypted.context = ctxCfg;
+      }
+      if (typeof payload["logLevel"] === "string") {
+        const logCfg = decrypted.log ?? {};
+        logCfg.level = payload["logLevel"];
+        decrypted.log = logCfg;
+      }
+      if (typeof payload["auditLevel"] === "string") {
+        const sessionCfg = decrypted.session ?? {};
+        sessionCfg.auditLevel = payload["auditLevel"];
+        decrypted.session = sessionCfg;
+      }
+      if (typeof payload["indexOnStart"] === "boolean") {
+        const indexingCfg = decrypted.indexing ?? {};
+        indexingCfg.onSessionStart = payload["indexOnStart"];
+        decrypted.indexing = indexingCfg;
+      }
+      if (typeof payload["maxIterations"] === "number") {
+        const toolsCfg = decrypted.tools ?? {};
+        toolsCfg.maxIterations = payload["maxIterations"];
+        decrypted.tools = toolsCfg;
+      }
+      const encrypted = encryptConfigSecrets2(decrypted, vault);
+      await atomicWrite5(globalConfigPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
+    };
+    const next = configWriteLock.then(write);
+    configWriteLock = next.then(
+      () => void 0,
+      () => void 0
+    );
+    try {
+      await next;
+    } catch (err) {
+      logger.warn(`prefs: failed to persist to config: ${errMessage(err)}`);
+    }
+  };
   const pipelines = createDefaultPipelines();
   const collabBus = new CollaborationBus();
   const collabPause = collabPauseMiddleware(collabBus, { logger });
@@ -2259,8 +3174,9 @@ async function startWebUI(opts = {}) {
   }
   const secretScrubber = container.resolve(TOKENS2.SecretScrubber);
   const renderer = container.has(TOKENS2.Renderer) ? container.resolve(TOKENS2.Renderer) : void 0;
+  const permissionPolicy = container.resolve(TOKENS2.PermissionPolicy);
   const toolExecutor = new ToolExecutor(toolRegistry, {
-    permissionPolicy: container.resolve(TOKENS2.PermissionPolicy),
+    permissionPolicy,
     secretScrubber,
     renderer,
     events,
@@ -2284,6 +3200,78 @@ async function startWebUI(opts = {}) {
     toolExecutor
   });
   console.log("[WebUI] Agent initialized");
+  const brainSettings = { maxAutoRisk: "medium" };
+  const autonomousBrain = {
+    decide: (request) => createAutonomyBrain({
+      provider,
+      model: context.model,
+      maxAutoRisk: "all"
+      // the tiered ceiling gates risk — keep inner permissive
+    }).decide(request)
+  };
+  const brain = new ObservableBrainArbiter(
+    createTieredBrainArbiter({
+      policy: new DefaultBrainArbiter(),
+      autonomous: autonomousBrain,
+      getMaxAutoRisk: () => brainSettings.maxAutoRisk
+    }),
+    events
+  );
+  container.bind(TOKENS2.BrainArbiter, () => brain);
+  const brainMailbox = new GlobalMailbox2(wpaths.projectDir, events);
+  const brainMonitor = new BrainMonitor({
+    events,
+    brain,
+    intervene: async ({ subject, body }) => {
+      const tag = mailboxSessionTag(session.id);
+      await brainMailbox.send({
+        from: `brain@${tag}`,
+        to: `leader@${tag}`,
+        type: "steer",
+        subject,
+        body,
+        priority: "high"
+      });
+    }
+  });
+  brainMonitor.start();
+  console.log("[WebUI] Brain initialized (tiered policy \u2192 LLM, monitor active)");
+  const brainLog = [];
+  const pushBrainLog = (entry) => {
+    brainLog.push(entry);
+    if (brainLog.length > 20) brainLog.shift();
+  };
+  events.on(
+    "brain.decision_answered",
+    (e) => pushBrainLog({
+      at: e.at,
+      kind: "answered",
+      question: e.request.question,
+      outcome: e.decision.type === "answer" ? e.decision.optionId ?? e.decision.text : ""
+    })
+  );
+  events.on(
+    "brain.decision_ask_human",
+    (e) => pushBrainLog({ at: e.at, kind: "ask_human", question: e.request.question, outcome: "needs human judgement" })
+  );
+  events.on(
+    "brain.decision_denied",
+    (e) => pushBrainLog({
+      at: e.at,
+      kind: "denied",
+      question: e.request.question,
+      outcome: e.decision.type === "deny" ? e.decision.reason : ""
+    })
+  );
+  events.on(
+    "brain.intervention",
+    (e) => pushBrainLog({
+      at: e.at,
+      kind: "intervention",
+      question: e.request.question,
+      outcome: e.intervened ? "steered the agent" : "observed (no action)"
+    })
+  );
   const autoPhaseHandler = new AutoPhaseWebSocketHandler(
     agent,
     context,
@@ -2322,15 +3310,16 @@ async function startWebUI(opts = {}) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path4.basename(projectRoot) || projectRoot,
-      cwd: projectRoot,
+      projectName: path8.basename(projectRoot) || projectRoot,
+      projectRoot,
+      cwd: workingDir,
       mode: modeId,
       contextMode: String(context.meta["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID),
       wsToken
     };
   }
   const wsToken = generateAuthToken();
-  console.log(`[WebUI] WS auth token: ${wsToken.slice(0, 4)}\u2026${wsToken.slice(-4)} (masked)`);
+  console.log("[WebUI] WS auth token generated (redacted from logs)");
   const verifyClient2 = (info) => verifyClient({
     origin: info.origin,
     url: info.req.url ?? "",
@@ -2353,6 +3342,13 @@ async function startWebUI(opts = {}) {
     maxPayload: WS_MAX_PAYLOAD
   }) : null;
   const clients = /* @__PURE__ */ new Map();
+  context.onWorkingDirChanged((newDir) => {
+    workingDir = newDir;
+    broadcast(clients, {
+      type: "working_dir.changed",
+      payload: { cwd: newDir, projectRoot }
+    });
+  });
   const RATE_LIMIT_MESSAGES = Number.parseInt(process.env["WEBUI_RATE_LIMIT"] ?? "0", 10);
   const RATE_LIMIT_WINDOW_MS = 6e4;
   const rateLimits = /* @__PURE__ */ new Map();
@@ -2377,9 +3373,15 @@ async function startWebUI(opts = {}) {
   const handleConnection = (ws) => {
     const client = { ws, sessionId: session.id, connectedAt: Date.now() };
     clients.set(ws, client);
-    console.log("[WebUI] Client connected, total:", clients.size);
     void sessionStartPayload().then((payload) => {
       send(ws, { type: "session.start", payload });
+    }).catch((err) => {
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "webui.session_start_payload_failed",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
     autoPhaseHandler.addClient(ws);
     worktreeHandler.addClient(ws);
@@ -2411,47 +3413,130 @@ async function startWebUI(opts = {}) {
           await handleMessage(ws, client, rawObj);
         }
       } catch (err) {
-        console.error("[WebUI] Failed to parse message", err);
+        console.error(JSON.stringify({
+          level: "error",
+          event: "webui.ws_message_parse_failed",
+          message: err instanceof Error ? err.message : String(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       }
     });
     ws.on("close", () => {
       clients.delete(ws);
       rateLimits.delete(String(ws));
-      console.log("[WebUI] Client disconnected, total:", clients.size);
       if (pendingConfirms.size > 0) {
-        for (const [id, resolve3] of pendingConfirms) {
-          resolve3("no");
+        for (const [id, resolve5] of pendingConfirms) {
+          resolve5("no");
           pendingConfirms.delete(id);
         }
       }
     });
     ws.on("error", (err) => {
-      console.warn("[WebUI] Client socket error:", err.message);
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "webui.client_socket_error",
+        message: err.message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
     });
   };
+  const sessionLogging = resolveSessionLoggingConfig(
+    config
+  );
+  const sessionBridge = createSessionEventBridge(
+    () => context.session ?? session,
+    sessionLogging.auditLevel,
+    { sampling: sessionLogging.sampling }
+  );
   let eventsArmed = false;
   const armOnce = (label) => {
     if (eventsArmed) return;
     eventsArmed = true;
     console.log(`[WebUI] Backend ready (${label})`);
-    setupEvents({ events, broadcast, clients, config, context, pendingConfirms });
+    setupEvents({ events, broadcast, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge });
   };
   wssPrimary.on("listening", () => armOnce(`${wsHost}:${wsPort}`));
   wssPrimary.on("connection", handleConnection);
   wssPrimary.on("error", (err) => {
-    console.error(`[WebUI] Primary WS server error (${wsHost}):`, err);
+    console.error(JSON.stringify({
+      level: "error",
+      event: "webui.ws_server_error",
+      host: wsHost,
+      message: err instanceof Error ? err.message : String(err),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
   });
   if (wssSecondary) {
     wssSecondary.on("listening", () => armOnce(`::1:${wsPort}`));
     wssSecondary.on("connection", handleConnection);
     wssSecondary.on("error", (err) => {
       if (err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL") {
-        console.warn("[WebUI] IPv6 loopback not available, v4-only:", err.code);
+        console.warn(JSON.stringify({
+          level: "warn",
+          event: "webui.ipv6_unavailable",
+          code: err.code,
+          message: err.message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       } else {
-        console.error("[WebUI] Secondary WS server error (::1):", err);
+        console.error(JSON.stringify({
+          level: "error",
+          event: "webui.ws_server_error",
+          host: "::1",
+          message: err.message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
       }
     });
   }
+  async function touchProjectEntry(root, workDir) {
+    const resolved = path8.resolve(root);
+    const manifest = await loadManifest(globalConfigPath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = manifest.projects.find((p) => path8.resolve(p.root) === resolved);
+    if (existing) {
+      existing.lastSeen = now;
+      if (workDir) existing.lastWorkingDir = path8.resolve(workDir);
+    } else {
+      manifest.projects.push({
+        name: path8.basename(resolved),
+        root: resolved,
+        slug: generateProjectSlug(resolved),
+        createdAt: now,
+        lastSeen: now,
+        lastWorkingDir: workDir ? path8.resolve(workDir) : void 0
+      });
+    }
+    await saveManifest(manifest, globalConfigPath);
+    await ensureProjectDataDir(generateProjectSlug(resolved), globalConfigPath);
+  }
+  function projectsJsonPath(globalConfigPath2) {
+    const base = path8.dirname(globalConfigPath2);
+    return path8.join(base, "projects.json");
+  }
+  async function loadManifest(globalConfigPath2) {
+    try {
+      const raw = await fs6.readFile(projectsJsonPath(globalConfigPath2), "utf8");
+      const parsed = JSON.parse(raw);
+      return { projects: parsed.projects ?? [] };
+    } catch {
+      return { projects: [] };
+    }
+  }
+  async function saveManifest(manifest, globalConfigPath2) {
+    const file = projectsJsonPath(globalConfigPath2);
+    await fs6.mkdir(path8.dirname(file), { recursive: true });
+    await fs6.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
+  }
+  function generateProjectSlug(rootPath) {
+    return projectSlug(rootPath);
+  }
+  async function ensureProjectDataDir(slug, globalConfigPath2) {
+    const base = path8.dirname(globalConfigPath2);
+    const dir = path8.join(base, "projects", slug);
+    await fs6.mkdir(dir, { recursive: true });
+    return dir;
+  }
   async function handleMessage(ws, _client, msg) {
     switch (msg.type) {
       // Collaboration messages short-circuit the user/agent flow.
@@ -2479,7 +3564,8 @@ async function startWebUI(opts = {}) {
         runLock = new AbortController();
         const thisRun = runLock;
         try {
-          const result = await agent.run(content, { signal: thisRun.signal });
+          const maxIt = typeof context.meta["maxIterations"] === "number" ? context.meta["maxIterations"] : void 0;
+          const result = await agent.run(content, { signal: thisRun.signal, maxIterations: maxIt });
           send(ws, {
             type: "run.result",
             payload: {
@@ -2510,10 +3596,10 @@ async function startWebUI(opts = {}) {
       }
       case "tool.confirm_result": {
         const { id, decision } = msg.payload;
-        const resolve3 = pendingConfirms.get(id);
-        if (resolve3) {
+        const resolve5 = pendingConfirms.get(id);
+        if (resolve5) {
           pendingConfirms.delete(id);
-          resolve3(decision);
+          resolve5(decision);
         }
         break;
       }
@@ -2525,6 +3611,15 @@ async function startWebUI(opts = {}) {
         send(ws, { type: "pong", payload: {} });
         break;
       case "session.new": {
+        try {
+          await session.append({
+            type: "session_end",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            usage: tokenCounter.total()
+          });
+          await session.close();
+        } catch {
+        }
         session = await sessionStore.create({
           id: "",
           title: "",
@@ -2618,29 +3713,35 @@ async function startWebUI(opts = {}) {
       }
       case "context.modes.list": {
         const active = String(context.meta["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID);
+        const allModes = customModeStore.list().map((m) => ({
+          id: m.id,
+          name: m.name,
+          description: m.description,
+          isActive: m.id === active,
+          thresholds: m.thresholds,
+          preserveK: m.preserveK,
+          eliseThreshold: m.eliseThreshold,
+          custom: m.custom === true
+        }));
         send(ws, {
           type: "context.modes.list",
-          payload: {
-            activeId: active,
-            modes: listContextWindowModes().map((m) => ({
-              id: m.id,
-              name: m.name,
-              description: m.description,
-              isActive: m.id === active,
-              thresholds: m.thresholds,
-              preserveK: m.preserveK,
-              eliseThreshold: m.eliseThreshold
-            }))
-          }
+          payload: { activeId: active, modes: allModes }
         });
         break;
       }
       case "context.mode.switch": {
         const { id } = msg.payload;
-        const policy = resolveContextWindowPolicy({}, id);
+        let policy = resolveContextWindowPolicy({}, id);
         if (policy.id !== id) {
-          sendResult(ws, false, `Unknown context mode "${id}"`);
-          break;
+          const customModes = customModeStore.list().filter(
+            (m) => m.custom === true
+          );
+          const custom = customModes.find((m) => m.id === id);
+          if (!custom) {
+            sendResult(ws, false, `Unknown context mode "${id}"`);
+            break;
+          }
+          policy = custom;
         }
         context.meta["contextWindowMode"] = policy.id;
         context.meta["contextWindowPolicy"] = policy;
@@ -2651,6 +3752,48 @@ async function startWebUI(opts = {}) {
         });
         break;
       }
+      case "context.mode.create": {
+        const payload = msg.payload;
+        const result = customModeStore.create({
+          id: payload.id,
+          name: payload.name,
+          description: payload.description,
+          thresholds: payload.thresholds,
+          preserveK: payload.preserveK,
+          eliseThreshold: payload.eliseThreshold,
+          custom: true,
+          aggressiveOn: "soft",
+          targetLoad: 0.65
+        });
+        sendResult(ws, result.ok, result.error ?? `Mode "${payload.id}" created`);
+        break;
+      }
+      case "context.mode.update": {
+        const payload = msg.payload;
+        const result = customModeStore.update(payload.id, {
+          name: payload.name,
+          description: payload.description,
+          thresholds: payload.thresholds ? {
+            warn: payload.thresholds.warn ?? 0.6,
+            soft: payload.thresholds.soft ?? 0.75,
+            hard: payload.thresholds.hard ?? 0.9
+          } : void 0,
+          preserveK: payload.preserveK,
+          eliseThreshold: payload.eliseThreshold
+        });
+        sendResult(ws, result.ok, result.error ?? `Mode "${payload.id}" updated`);
+        break;
+      }
+      case "context.mode.delete": {
+        const { id } = msg.payload;
+        if (String(context.meta["contextWindowMode"] ?? "") === id) {
+          context.meta["contextWindowMode"] = DEFAULT_CONTEXT_WINDOW_MODE_ID;
+          context.meta["contextWindowPolicy"] = resolveContextWindowPolicy({}, DEFAULT_CONTEXT_WINDOW_MODE_ID);
+        }
+        const result = customModeStore.remove(id);
+        sendResult(ws, result.ok, result.error ?? `Mode "${id}" deleted`);
+        break;
+      }
       case "providers.list": {
         const providers = await modelsRegistry.listProviders();
         const savedIds = new Set(Object.keys(config.providers ?? {}));
@@ -2730,15 +3873,20 @@ async function startWebUI(opts = {}) {
           updateAutoCompactionMaxContext?.(newProv);
           try {
             configWriteLock = configWriteLock.then(async () => {
-              const raw = await fs4.readFile(globalConfigPath, "utf8");
+              const raw = await fs6.readFile(globalConfigPath, "utf8");
               const parsed = JSON.parse(raw);
               parsed.provider = newProvider;
               parsed.model = newModel;
-              await atomicWrite3(globalConfigPath, JSON.stringify(parsed, null, 2));
+              await atomicWrite5(globalConfigPath, JSON.stringify(parsed, null, 2));
             });
             await configWriteLock;
           } catch (err) {
-            console.warn("[WebUI] Failed to save config:", err);
+            console.warn(JSON.stringify({
+              level: "warn",
+              event: "webui.config_save_failed",
+              message: err instanceof Error ? err.message : String(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }));
           }
           send(ws, {
             type: "key.operation_result",
@@ -2757,6 +3905,57 @@ async function startWebUI(opts = {}) {
         broadcast(clients, { type: "session.start", payload: await sessionStartPayload() });
         break;
       }
+      case "model.refine": {
+        const { text } = msg.payload;
+        if (!text?.trim()) {
+          send(ws, {
+            type: "model.refine_result",
+            payload: { refined: "", english: "", error: "Empty text" }
+          });
+          break;
+        }
+        try {
+          const history = recentTextTurns(context.messages);
+          const result = await enhanceUserPrompt({
+            provider: context.provider,
+            model: context.model,
+            text,
+            history,
+            timeoutMs: 9e4,
+            onError: (reason) => {
+              console.warn(JSON.stringify({
+                level: "warn",
+                event: "model.refine_failed",
+                reason,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }));
+            }
+          });
+          if (result) {
+            send(ws, {
+              type: "model.refine_result",
+              payload: { refined: result.refined, english: result.english }
+            });
+          } else {
+            send(ws, {
+              type: "model.refine_result",
+              payload: { refined: text, english: text, error: "Refinement returned no result" }
+            });
+          }
+        } catch (err) {
+          console.error(JSON.stringify({
+            level: "error",
+            event: "model.refine.error",
+            error: errMessage(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+          send(ws, {
+            type: "model.refine_result",
+            payload: { refined: text, english: text, error: errMessage(err) }
+          });
+        }
+        break;
+      }
       case "key.add":
       case "key.update": {
         const { providerId, label, apiKey } = msg.payload;
@@ -2832,6 +4031,11 @@ async function startWebUI(opts = {}) {
           }
           const resumed = await sessionStore.resume(id);
           try {
+            await session.append({
+              type: "session_end",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              usage: tokenCounter.total()
+            });
             await session.close();
           } catch {
           }
@@ -2875,42 +4079,13 @@ async function startWebUI(opts = {}) {
         send(ws, { type: "tools.list", payload: { tools: list } });
         break;
       }
-      case "memory.list": {
-        try {
-          const text = await memoryStore.readAll();
-          send(ws, { type: "memory.list", payload: { text } });
-        } catch (err) {
-          send(ws, {
-            type: "memory.list",
-            payload: { text: "", error: errMessage(err) }
-          });
-        }
-        break;
-      }
-      case "memory.remember": {
-        const { text, scope } = msg.payload;
-        try {
-          await memoryStore.remember(text, scope ?? "project-memory");
-          sendResult(ws, true, "Saved to memory");
-        } catch (err) {
-          sendResult(ws, false, errMessage(err));
-        }
-        break;
-      }
-      case "memory.forget": {
-        const { text, scope } = msg.payload;
-        try {
-          const removed = await memoryStore.forget(text, scope ?? "project-memory");
-          sendResult(
-            ws,
-            removed > 0,
-            removed > 0 ? `Removed ${removed} entr${removed === 1 ? "y" : "ies"}` : "No matching entries"
-          );
-        } catch (err) {
-          sendResult(ws, false, errMessage(err));
-        }
-        break;
-      }
+      // ── Memory operations — delegated to shared handlers (memory-handlers.ts) ──
+      case "memory.list":
+        return handleMemoryList(ws, memoryStore);
+      case "memory.remember":
+        return handleMemoryRemember(ws, msg, memoryStore);
+      case "memory.forget":
+        return handleMemoryForget(ws, msg, memoryStore);
       case "skills.list": {
         if (!skillLoader) {
           send(ws, { type: "skills.list", payload: { skills: [], enabled: false } });
@@ -3010,6 +4185,24 @@ async function startWebUI(opts = {}) {
         broadcast(clients, { type: "todos.updated", payload: { todos: next } });
         break;
       }
+      case "tasks.get": {
+        const taskPath = context.meta["task.path"];
+        if (typeof taskPath === "string" && taskPath) {
+          try {
+            const { loadTasks } = await import("@wrongstack/core");
+            const file = await loadTasks(taskPath);
+            send(ws, {
+              type: "tasks.updated",
+              payload: { tasks: file?.tasks ?? [] }
+            });
+          } catch {
+            send(ws, { type: "tasks.updated", payload: { tasks: [] } });
+          }
+        } else {
+          send(ws, { type: "tasks.updated", payload: { tasks: [], error: "Task storage not configured." } });
+        }
+        break;
+      }
       case "plan.get": {
         const planPath = context.meta["plan.path"];
         if (typeof planPath === "string" && planPath) {
@@ -3077,37 +4270,18 @@ async function startWebUI(opts = {}) {
         }
         break;
       }
-      case "files.list": {
-        const payload = msg.payload ?? {};
-        const limit = payload.limit ?? 50;
-        const results = [];
-        async function walk(dir, rel, depth) {
-          if (depth > 8 || results.length >= 600) return;
-          let entries = [];
-          try {
-            entries = await fs4.readdir(dir, { withFileTypes: true });
-          } catch {
-            return;
-          }
-          for (const e of entries) {
-            if (results.length >= 600) return;
-            if (isHiddenEntry(e.name)) continue;
-            const childRel = rel ? `${rel}/${e.name}` : e.name;
-            if (e.isDirectory()) {
-              if (SKIP_DIRS.has(e.name)) continue;
-              await walk(path4.join(dir, e.name), childRel, depth + 1);
-            } else if (e.isFile()) {
-              results.push(childRel);
-            }
-          }
-        }
-        await walk(projectRoot, "", 0);
-        send(ws, {
-          type: "files.list",
-          payload: { files: rankFiles(results, payload.query ?? "", limit) }
-        });
-        break;
-      }
+      // ── File operations — delegated to shared handlers (file-handlers.ts) ──
+      // These handlers are also used by the CLI's webui-server.ts. When
+      // adding or modifying file-operation WebSocket messages, update
+      // file-handlers.ts — NOT these case blocks individually.
+      case "files.list":
+        return handleFilesList(ws, msg, projectRoot);
+      case "files.tree":
+        return handleFilesTree(ws, msg, projectRoot);
+      case "files.read":
+        return handleFilesRead(ws, msg, projectRoot);
+      case "files.write":
+        return handleFilesWrite(ws, msg, projectRoot);
       case "modes.list": {
         try {
           const modes = await modeStore.listModes();
@@ -3245,8 +4419,8 @@ async function startWebUI(opts = {}) {
       }
       case "goal.get": {
         try {
-          const goalPath = path4.join(projectRoot, ".wrongstack", "goal.json");
-          const raw = await fs4.readFile(goalPath, "utf8");
+          const goalPath = path8.join(projectRoot, ".wrongstack", "goal.json");
+          const raw = await fs6.readFile(goalPath, "utf8");
           const goal = JSON.parse(raw);
           broadcast(clients, { type: "goal.updated", payload: goal });
         } catch {
@@ -3258,13 +4432,55 @@ async function startWebUI(opts = {}) {
         const { mode } = msg.payload;
         context.meta["autonomy"] = mode;
         sendResult(ws, true, `Autonomy mode set to "${mode}"`);
+        broadcast(clients, { type: "prefs.updated", payload: { autonomy: mode } });
+        void persistPrefsToConfig({ autonomy: mode });
+        break;
+      }
+      case "prefs.update": {
+        const payload = msg.payload;
+        for (const [key, val] of Object.entries(payload)) {
+          context.meta[key] = val;
+        }
+        void persistPrefsToConfig(payload);
+        if (typeof payload["yolo"] === "boolean") {
+          permissionPolicy.setYolo?.(payload["yolo"]);
+        }
+        if (typeof payload["featureMcp"] === "boolean")
+          config.features.mcp = payload["featureMcp"];
+        if (typeof payload["featurePlugins"] === "boolean")
+          config.features.plugins = payload["featurePlugins"];
+        if (typeof payload["featureMemory"] === "boolean")
+          config.features.memory = payload["featureMemory"];
+        if (typeof payload["featureSkills"] === "boolean")
+          config.features.skills = payload["featureSkills"];
+        if (typeof payload["featureModelsRegistry"] === "boolean")
+          config.features.modelsRegistry = payload["featureModelsRegistry"];
+        if (typeof payload["contextAutoCompact"] === "boolean") {
+          if (payload["contextAutoCompact"] && autoCompactor) {
+            pipelines.contextWindow.remove("AutoCompaction", { optional: true });
+            pipelines.contextWindow.use({ name: "AutoCompaction", handler: autoCompactor.handler() });
+          } else {
+            pipelines.contextWindow.remove("AutoCompaction", { optional: true });
+          }
+        }
+        if (typeof payload["logLevel"] === "string") {
+          const valid = ["debug", "info", "warn", "error"];
+          if (valid.includes(payload["logLevel"])) {
+            logger.level = payload["logLevel"];
+          }
+        }
+        broadcast(clients, { type: "prefs.updated", payload: prefSnapshot() });
+        break;
+      }
+      case "prefs.get": {
+        send(ws, { type: "prefs.updated", payload: prefSnapshot() });
         break;
       }
       case "session.checkpoints": {
         try {
           const { DefaultSessionRewinder } = await import("@wrongstack/core");
           const rewinder = new DefaultSessionRewinder(
-            path4.join(projectRoot, ".wrongstack", "sessions"),
+            path8.join(projectRoot, ".wrongstack", "sessions"),
             projectRoot
           );
           const checkpoints = await rewinder.listCheckpoints(session.id);
@@ -3285,7 +4501,7 @@ async function startWebUI(opts = {}) {
         try {
           const { DefaultSessionRewinder } = await import("@wrongstack/core");
           const rewinder = new DefaultSessionRewinder(
-            path4.join(projectRoot, ".wrongstack", "sessions"),
+            path8.join(projectRoot, ".wrongstack", "sessions"),
             projectRoot
           );
           await rewinder.rewindToCheckpoint(session.id, checkpointIndex);
@@ -3300,6 +4516,309 @@ async function startWebUI(opts = {}) {
         }
         break;
       }
+      // ── Project management ────────────────────────────────────────────
+      case "projects.list": {
+        try {
+          const manifest = await loadManifest(globalConfigPath);
+          send(ws, {
+            type: "projects.list",
+            payload: { projects: manifest.projects }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "projects.list",
+            payload: { projects: [], error: errMessage(err) }
+          });
+        }
+        break;
+      }
+      case "projects.add": {
+        const { root: addRoot, name: displayName } = msg.payload;
+        try {
+          const resolved = path8.resolve(addRoot);
+          await fs6.access(resolved);
+          const stat2 = await fs6.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);
+          if (existing) {
+            send(ws, {
+              type: "projects.added",
+              payload: {
+                name: existing.name,
+                root: existing.root,
+                slug: existing.slug,
+                message: `Already registered as "${existing.name}"`
+              }
+            });
+            break;
+          }
+          const name = displayName?.trim() || path8.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 });
+          await saveManifest(manifest, globalConfigPath);
+          send(ws, {
+            type: "projects.added",
+            payload: {
+              name,
+              root: resolved,
+              slug,
+              message: `Registered project "${name}"`
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "projects.added",
+            payload: {
+              name: path8.basename(addRoot),
+              root: addRoot,
+              slug: "",
+              message: errMessage(err)
+            }
+          });
+        }
+        break;
+      }
+      case "projects.select": {
+        const { root: selRoot, name: selName } = msg.payload;
+        try {
+          const resolved = path8.resolve(selRoot);
+          try {
+            await fs6.access(resolved);
+            const stat2 = await fs6.stat(resolved);
+            if (!stat2.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+          } catch (err) {
+            send(ws, {
+              type: "projects.selected",
+              payload: {
+                root: selRoot,
+                name: selName || path8.basename(selRoot),
+                message: `Cannot switch: ${errMessage(err)}`
+              }
+            });
+            break;
+          }
+          const manifest = await loadManifest(globalConfigPath);
+          const entry = manifest.projects.find((p) => p.root === resolved);
+          if (entry) {
+            entry.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+            entry.lastWorkingDir = resolved;
+          } else {
+            const name = selName?.trim() || path8.basename(resolved);
+            const slug = generateProjectSlug(resolved);
+            manifest.projects.push({
+              name,
+              root: resolved,
+              slug,
+              lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              lastWorkingDir: resolved
+            });
+            await ensureProjectDataDir(slug, globalConfigPath);
+          }
+          await saveManifest(manifest, globalConfigPath);
+          if (runLock) {
+            runLock.abort();
+            runLock = null;
+          }
+          projectRoot = resolved;
+          workingDir = resolved;
+          context.cwd = workingDir;
+          context.projectRoot = projectRoot;
+          const newSessionsDir = path8.join(
+            path8.dirname(globalConfigPath),
+            "projects",
+            entry?.slug ?? generateProjectSlug(resolved),
+            "sessions"
+          );
+          await fs6.mkdir(newSessionsDir, { recursive: true });
+          const newSessionStore = new DefaultSessionStore2({ dir: newSessionsDir });
+          const oldSessionId = session.id;
+          try {
+            await session.append({
+              type: "session_end",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              usage: tokenCounter.total()
+            });
+            await session.close();
+          } catch {
+          }
+          sessionStore = newSessionStore;
+          session = await sessionStore.create({
+            id: "",
+            title: "",
+            model: config.model,
+            provider: config.provider
+          });
+          context.session = session;
+          context.state.replaceMessages([]);
+          context.state.replaceTodos([]);
+          context.readFiles.clear();
+          context.fileMtimes.clear();
+          tokenCounter.reset();
+          sessionStartedAt = Date.now();
+          send(ws, {
+            type: "projects.selected",
+            payload: {
+              root: resolved,
+              name: selName || path8.basename(resolved),
+              message: `Switched to ${selName || path8.basename(resolved)}`
+            }
+          });
+          broadcast(clients, {
+            type: "subagent.event",
+            payload: {
+              kind: "session_stopped",
+              sessionId: oldSessionId
+            }
+          });
+          broadcast(clients, {
+            type: "session.start",
+            payload: {
+              ...await sessionStartPayload(),
+              reset: true,
+              clearedSessionId: oldSessionId
+            }
+          });
+        } catch (err) {
+          send(ws, {
+            type: "projects.selected",
+            payload: {
+              root: selRoot,
+              name: selName || path8.basename(selRoot),
+              message: errMessage(err)
+            }
+          });
+        }
+        break;
+      }
+      // ── Working directory (within current project) ───────────────────
+      case "working_dir.set": {
+        const { path: newPath } = msg.payload;
+        try {
+          const resolved = path8.resolve(projectRoot, newPath);
+          if (!resolved.startsWith(projectRoot + path8.sep) && resolved !== projectRoot) {
+            sendResult(ws, false, `Path must stay inside the project root: ${projectRoot}`);
+            break;
+          }
+          try {
+            await fs6.access(resolved);
+            const stat2 = await fs6.stat(resolved);
+            if (!stat2.isDirectory()) throw new Error("Not a directory");
+          } catch {
+            sendResult(ws, false, `Directory not found or not accessible: ${resolved}`);
+            break;
+          }
+          workingDir = resolved;
+          context.cwd = resolved;
+          broadcast(clients, {
+            type: "working_dir.changed",
+            payload: { cwd: resolved, projectRoot }
+          });
+          sendResult(ws, true, `Working directory set to ${resolved}`);
+        } catch (err) {
+          sendResult(ws, false, errMessage(err));
+        }
+        break;
+      }
+      // ── Shell open — spawn terminal or file manager at a path ─────────
+      case "shell.open": {
+        const { path: targetPath, target } = msg.payload;
+        try {
+          const resolved = path8.resolve(targetPath);
+          await fs6.access(resolved);
+          const { exec } = await import("child_process");
+          const platform = process.platform;
+          let cmd;
+          if (target === "file-manager") {
+            if (platform === "win32") {
+              cmd = `explorer "${resolved}"`;
+            } else if (platform === "darwin") {
+              cmd = `open "${resolved}"`;
+            } else {
+              cmd = `xdg-open "${resolved}"`;
+            }
+          } else {
+            if (platform === "win32") {
+              cmd = `start cmd /k cd /d "${resolved}"`;
+            } else if (platform === "darwin") {
+              cmd = `open -a Terminal "${resolved}"`;
+            } else {
+              cmd = `x-terminal-emulator --working-directory="${resolved}" 2>/dev/null || gnome-terminal --working-directory="${resolved}" 2>/dev/null || xterm -e "cd '${resolved}' && $SHELL"`;
+            }
+          }
+          exec(cmd, { timeout: 5e3 }, (err) => {
+            if (err) {
+              logger.warn(`shell.open failed: ${err.message}`);
+            }
+          });
+          sendResult(ws, true, `Opened ${target} at ${resolved}`);
+        } catch (err) {
+          sendResult(ws, false, errMessage(err));
+        }
+        break;
+      }
+      // ── Mailbox operations — project-level inter-agent messaging ────
+      case "mailbox.messages":
+        return handleMailboxMessages(
+          ws,
+          { projectRoot, globalRoot: path8.dirname(globalConfigPath) },
+          msg.payload
+        );
+      case "mailbox.agents":
+        return handleMailboxAgents(
+          ws,
+          { projectRoot, globalRoot: path8.dirname(globalConfigPath) },
+          msg.payload
+        );
+      case "mailbox.clear":
+        return handleMailboxClear(
+          ws,
+          { projectRoot, globalRoot: path8.dirname(globalConfigPath) }
+        );
+      // ── Brain — status, autonomy ceiling, direct decision support ───
+      case "brain.status":
+        send(ws, {
+          type: "brain.status",
+          payload: { maxAutoRisk: brainSettings.maxAutoRisk, log: brainLog }
+        });
+        break;
+      case "brain.risk": {
+        const level = msg.payload?.level ?? "";
+        const valid = ["off", "low", "medium", "high", "all"];
+        if (!valid.includes(level)) {
+          sendResult(ws, false, `Unknown risk level "${level}". Use: ${valid.join(", ")}.`);
+          break;
+        }
+        brainSettings.maxAutoRisk = level;
+        send(ws, {
+          type: "brain.status",
+          payload: { maxAutoRisk: brainSettings.maxAutoRisk, log: brainLog }
+        });
+        break;
+      }
+      case "brain.ask": {
+        const question = msg.payload?.question?.trim();
+        if (!question) {
+          sendResult(ws, false, "Usage: /brain ask <question>");
+          break;
+        }
+        try {
+          const decision = await brain.decide({
+            id: `brain-ask-${Date.now().toString(36)}`,
+            source: "user",
+            question,
+            risk: "medium",
+            fallback: "ask_human"
+          });
+          send(ws, { type: "brain.answer", payload: { question, decision } });
+        } catch (err) {
+          sendResult(ws, false, `Brain consultation failed: ${errMessage(err)}`);
+        }
+        break;
+      }
       default:
         if (msg.type.startsWith("autophase.")) {
           await autoPhaseHandler.handleMessage(
@@ -3319,14 +4838,16 @@ async function startWebUI(opts = {}) {
     getConfigWriteLock: () => configWriteLock,
     setConfigWriteLock: (p) => {
       configWriteLock = p;
-    }
+    },
+    broadcast,
+    clients
   });
   const httpServer = createHttpServer({
     host: wsHost,
-    distDir: path4.resolve(import.meta.dirname, "../../dist"),
+    distDir: path8.resolve(import.meta.dirname, "../../dist"),
     wsPort
   });
-  const registryBaseDir = path4.dirname(globalConfigPath);
+  const registryBaseDir = path8.dirname(globalConfigPath);
   httpServer.listen(httpPort, wsHost, () => {
     const openUrl = `http://${wsHost}:${httpPort}`;
     console.log(`[WebUI] HTTP server running on ${openUrl}`);
@@ -3338,12 +4859,17 @@ async function startWebUI(opts = {}) {
         wsPort,
         host: wsHost,
         projectRoot,
-        projectName: path4.basename(projectRoot) || projectRoot,
+        projectName: path8.basename(projectRoot) || projectRoot,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         url: `http://${wsHost}:${httpPort}`
       },
       registryBaseDir
-    ).catch((err) => console.warn("[WebUI] Could not record instance:", errMessage(err)));
+    ).catch((err) => console.warn(JSON.stringify({
+      level: "warn",
+      event: "webui.instance_record_failed",
+      message: errMessage(err),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    })));
   });
   registerShutdownHandlers({
     flushSession: async () => {
@@ -3358,7 +4884,10 @@ async function startWebUI(opts = {}) {
     servers: [httpServer, wssPrimary, wssSecondary],
     // Drop this instance from the registry on a clean exit so the file reflects
     // reality. Crash exits are healed by the next register()/list() prune pass.
-    onShutdown: () => unregisterInstance(process.pid, registryBaseDir)
+    onShutdown: () => {
+      brainMonitor.stop();
+      return unregisterInstance(process.pid, registryBaseDir);
+    }
   });
 }
 
@@ -3369,7 +4898,12 @@ if (argv.includes("--list") || argv.includes("-l") || argv[0] === "ls") {
     console.log(formatInstances(instances));
     process.exit(0);
   }).catch((err) => {
-    console.error("[WebUI] Could not read instance registry:", err);
+    console.error(JSON.stringify({
+      level: "fatal",
+      event: "webui.instance_registry_read_failed",
+      message: err instanceof Error ? err.message : String(err),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
     process.exit(1);
   });
 } else {
@@ -3378,7 +4912,12 @@ if (argv.includes("--list") || argv.includes("-l") || argv[0] === "ls") {
   const open = argv.includes("--open") || argv.includes("-o") || process.env["WEBUI_OPEN"] === "1";
   console.log(`[WebUI] Starting standalone server on ${wsHost}:${wsPort}...`);
   startWebUI({ wsPort, wsHost, open }).catch((err) => {
-    console.error("[WebUI] Fatal error:", err);
+    console.error(JSON.stringify({
+      level: "fatal",
+      event: "webui.startup_failed",
+      message: err instanceof Error ? err.message : String(err),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
     process.exit(1);
   });
 }