@wrongstack/webui-server 0.296.4 → 0.298.0

package/dist/server/entry.js

@@ -6,9 +6,13 @@ import { ToolValidationError as ToolValidationError6 } from "@wrongstack/core/ty
 import { getProcessRegistry } from "@wrongstack/tools";
 
 // src/server/pending-confirms.ts
+function isDestructivePendingConfirm(confirm) {
+  return confirm.riskTier === "destructive" || confirm.decisionSource === "yolo_destructive";
+}
 function resolveYoloEligiblePendingConfirms(pendingConfirms) {
   for (const [id, confirm] of pendingConfirms) {
     if (confirm.boundaryReason) continue;
+    if (isDestructivePendingConfirm(confirm)) continue;
     pendingConfirms.delete(id);
     confirm.resolve("yes");
   }
@@ -72,7 +76,18 @@ var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   "showModelReasoning",
   // Display-only toggles (purely visual, persisted in localStorage via Zustand).
   "groupToolCalls",
-  "showThinkingLogs"
+  "showThinkingLogs",
+  // v11 Display parity: agent-swarm panel + inverse fsAccess flag.
+  "showAgentSwarmPanel",
+  "allowOutsideProjectRoot",
+  // v13 Display parity (TUI SettingsPicker fields 42 & 43): the read tool
+  // includes codebase-index symbols, and SAGE memory-inject blocks are
+  // surfaced in tool results. Both are pure WebUI-display toggles mirrored
+  // against the TUI's settings picker; the server mirrors them through
+  // `prefs.update` exactly so the panel does not error with
+  // "unknown preference key".
+  "readSymbols",
+  "showSageMemoryInject"
 ]);
 var STRING_ARRAY_PREF_KEYS = /* @__PURE__ */ new Set([
   "fallbackModels",
@@ -93,14 +108,39 @@ var NUMBER_PREF_KEYS = /* @__PURE__ */ new Set([
   "maxIterations",
   "maxConcurrent",
   "enhanceDelayMs",
+  "enhanceCountdownMs",
   "tgLongToolMs",
   "breakerAutoKillResetMs",
   // Chimera + auto-review numeric knobs
   "chimeraMaxFiles",
   "autoReviewDebounceMs",
   "autoReviewMaxFilesPerBatch",
-  "autoReviewMaxConcurrentReviews"
+  "autoReviewMaxConcurrentReviews",
+  // v13 Display parity (TUI SettingsPicker fields 41, 44, 21): the
+  // pre-refine grace countdown (seconds), the SAGE memory-inject relation
+  // floor (0..1), and the minimum file count for the multi-diff summary
+  // footer. All three are driven by the WebUI sliders in DisplaySection
+  // and previously tripped the "unknown preference key" rejection.
+  "preRefineSeconds",
+  "sageMemoryInjectThreshold",
+  "multiDiffSummaryThreshold"
 ]);
+var NUMBER_PREF_BOUNDS = {
+  // Iteration / concurrency — must be at least 1 to make progress.
+  maxIterations: { min: 1, max: Number.POSITIVE_INFINITY },
+  maxConcurrent: { min: 1, max: Number.POSITIVE_INFINITY },
+  autoProceedMaxIterations: { min: 1, max: Number.POSITIVE_INFINITY },
+  chimeraMaxFiles: { min: 1, max: Number.POSITIVE_INFINITY },
+  autoReviewMaxFilesPerBatch: { min: 1, max: Number.POSITIVE_INFINITY },
+  autoReviewMaxConcurrentReviews: { min: 1, max: Number.POSITIVE_INFINITY },
+  // Counts (must be >= 1 to render a footer at all).
+  multiDiffSummaryThreshold: { min: 1, max: Number.POSITIVE_INFINITY },
+  preRefineSeconds: { min: 0, max: Number.POSITIVE_INFINITY },
+  // Probability — must lie in [0, 1].
+  sageMemoryInjectThreshold: { min: 0, max: 1 },
+  // Debounce / delay — non-negative ms.
+  autoReviewDebounceMs: { min: 0, max: Number.POSITIVE_INFINITY }
+};
 var STRING_PREF_KEYS = /* @__PURE__ */ new Set([
   "hqUrl",
   "hqToken",
@@ -135,85 +175,85 @@ var ENUM_PREF_KEYS = {
   autoReviewCascadeOn: /* @__PURE__ */ new Set(["off", "critical", "high"]),
   fleetChatVerbosity: /* @__PURE__ */ new Set(["off", "full"])
 };
-function validateModelRuntimeValue(modelRuntime, path29) {
+function validateModelRuntimeValue(modelRuntime, path30) {
   const reasoning = modelRuntime["reasoning"];
   if (reasoning !== void 0) {
-    if (!isRecord(reasoning)) return `${path29}.reasoning must be an object when provided`;
+    if (!isRecord(reasoning)) return `${path30}.reasoning must be an object when provided`;
     const mode = reasoning["mode"];
     const effort = reasoning["effort"];
     const preserve = reasoning["preserve"];
     if (mode !== void 0 && (typeof mode !== "string" || !REASONING_MODE_VALUES.has(mode))) {
-      return `${path29}.reasoning.mode must be one of: ${Array.from(REASONING_MODE_VALUES).join(", ")}`;
+      return `${path30}.reasoning.mode must be one of: ${Array.from(REASONING_MODE_VALUES).join(", ")}`;
     }
     if (effort !== void 0 && (typeof effort !== "string" || !REASONING_EFFORT_VALUES.has(effort))) {
-      return `${path29}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
+      return `${path30}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
     }
     if (preserve !== void 0 && typeof preserve !== "boolean") {
-      return `${path29}.reasoning.preserve must be a boolean when provided`;
+      return `${path30}.reasoning.preserve must be a boolean when provided`;
     }
   }
   const cache2 = modelRuntime["cache"];
   if (cache2 !== void 0) {
-    if (!isRecord(cache2)) return `${path29}.cache must be an object when provided`;
+    if (!isRecord(cache2)) return `${path30}.cache must be an object when provided`;
     const ttl = cache2["ttl"];
     if (ttl !== void 0 && (typeof ttl !== "string" || !CACHE_TTL_VALUES.has(ttl) || ttl === "default")) {
-      return `${path29}.cache.ttl must be one of: 5m, 1h`;
+      return `${path30}.cache.ttl must be one of: 5m, 1h`;
     }
   }
   const parameters = modelRuntime["parameters"];
   if (parameters !== void 0 && !isRecord(parameters)) {
-    return `${path29}.parameters must be an object when provided`;
+    return `${path30}.parameters must be an object when provided`;
   }
   return null;
 }
-function validateModelBlackoutRule(rule, path29) {
+function validateModelBlackoutRule(rule, path30) {
   const id = rule["id"];
   if (typeof id !== "string" || id.trim().length === 0) {
-    return `${path29}.id must be a non-empty string`;
+    return `${path30}.id must be a non-empty string`;
   }
   const start = rule["start"];
   if (typeof start !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(start)) {
-    return `${path29}.start must be a string in HH:mm (00:00-23:59) format`;
+    return `${path30}.start must be a string in HH:mm (00:00-23:59) format`;
   }
   const end = rule["end"];
   if (typeof end !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(end)) {
-    return `${path29}.end must be a string in HH:mm (00:00-23:59) format`;
+    return `${path30}.end must be a string in HH:mm (00:00-23:59) format`;
   }
   if (rule["enabled"] !== void 0 && typeof rule["enabled"] !== "boolean") {
-    return `${path29}.enabled must be a boolean when provided`;
+    return `${path30}.enabled must be a boolean when provided`;
   }
   if (rule["provider"] !== void 0 && typeof rule["provider"] !== "string") {
-    return `${path29}.provider must be a string when provided`;
+    return `${path30}.provider must be a string when provided`;
   }
   if (rule["model"] !== void 0 && typeof rule["model"] !== "string") {
-    return `${path29}.model must be a string when provided`;
+    return `${path30}.model must be a string when provided`;
   }
   if (rule["days"] !== void 0) {
-    if (!Array.isArray(rule["days"])) return `${path29}.days must be an array when provided`;
+    if (!Array.isArray(rule["days"])) return `${path30}.days must be an array when provided`;
     const seen = /* @__PURE__ */ new Set();
     for (const d of rule["days"]) {
       if (typeof d !== "number" || !Number.isInteger(d) || d < 0 || d > 6) {
-        return `${path29}.days elements must be integers 0-6 when provided`;
+        return `${path30}.days elements must be integers 0-6 when provided`;
       }
-      if (seen.has(d)) return `${path29}.days contains duplicate day: ${d}`;
+      if (seen.has(d)) return `${path30}.days contains duplicate day: ${d}`;
       seen.add(d);
     }
   }
   if (rule["timezone"] !== void 0) {
     if (typeof rule["timezone"] !== "string") {
-      return `${path29}.timezone must be a string when provided`;
+      return `${path30}.timezone must be a string when provided`;
     }
     try {
       Intl.DateTimeFormat(void 0, { timeZone: rule["timezone"] });
     } catch {
-      return `${path29}.timezone is not a valid IANA timezone (e.g. "America/New_York")`;
+      return `${path30}.timezone is not a valid IANA timezone (e.g. "America/New_York")`;
     }
   }
   if (rule["label"] !== void 0 && typeof rule["label"] !== "string") {
-    return `${path29}.label must be a string when provided`;
+    return `${path30}.label must be a string when provided`;
   }
   if (rule["mode"] !== void 0 && rule["mode"] !== "blackout" && rule["mode"] !== "allow_only") {
-    return `${path29}.mode must be 'blackout' or 'allow_only' when provided`;
+    return `${path30}.mode must be 'blackout' or 'allow_only' when provided`;
   }
   return null;
 }
@@ -222,7 +262,15 @@ function validatePreferenceValue(key, value) {
     return typeof value === "boolean" ? null : `prefs.update payload.${key} must be a boolean`;
   }
   if (NUMBER_PREF_KEYS.has(key)) {
-    return typeof value === "number" && Number.isFinite(value) ? null : `prefs.update payload.${key} must be a finite number`;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return `prefs.update payload.${key} must be a finite number`;
+    }
+    const bounds = NUMBER_PREF_BOUNDS[key];
+    if (bounds && (value < bounds.min || value > bounds.max)) {
+      const maxStr = bounds.max === Number.POSITIVE_INFINITY ? "\u221E" : String(bounds.max);
+      return `prefs.update payload.${key} must be in [${bounds.min}, ${maxStr}]`;
+    }
+    return null;
   }
   if (STRING_PREF_KEYS.has(key)) {
     return typeof value === "string" ? null : `prefs.update payload.${key} must be a string`;
@@ -246,9 +294,16 @@ function validatePreferenceValue(key, value) {
     return null;
   }
   if (STRING_ARRAY_RECORD_PREF_KEYS.has(key)) {
-    return isRecord(value) && Object.values(value).every(
+    if (!isRecord(value) || !Object.values(value).every(
       (v) => Array.isArray(v) && v.every((item) => typeof item === "string")
-    ) ? null : `prefs.update payload.${key} must be an object of string arrays`;
+    )) {
+      return `prefs.update payload.${key} must be an object of string arrays`;
+    }
+    const badKey = Object.keys(value).find((k) => FORBIDDEN_PROTO_KEYS.has(k));
+    if (badKey) {
+      return `prefs.update payload.${key} contains a forbidden key: ${badKey}`;
+    }
+    return null;
   }
   if (BOOLEAN_RECORD_PREF_KEYS.has(key)) {
     if (!isRecord(value) || !Object.values(value).every((v) => typeof v === "boolean")) {
@@ -262,6 +317,10 @@ function validatePreferenceValue(key, value) {
   }
   if (MODEL_MATRIX_PREF_KEYS.has(key)) {
     if (!isRecord(value)) return `prefs.update payload.${key} must be an object`;
+    const badMatrixKey = Object.keys(value).find((k) => FORBIDDEN_PROTO_KEYS.has(k));
+    if (badMatrixKey) {
+      return `prefs.update payload.${key} contains a forbidden key: ${badMatrixKey}`;
+    }
     for (const entry of Object.values(value)) {
       if (!isRecord(entry)) return `prefs.update payload.${key} entries must be objects`;
       const provider = entry["provider"];
@@ -386,6 +445,37 @@ function validateMailboxMessagesPayload(payload) {
     }
   };
 }
+var MAILBOX_ACTIONS = /* @__PURE__ */ new Set(["mark-read", "acknowledge", "reopen", "soft-delete"]);
+function validateMailboxActionPayload(payload) {
+  if (!isRecord2(payload)) {
+    return { ok: false, message: "mailbox.action payload must be an object" };
+  }
+  const requestId = payload["requestId"];
+  const mailId = payload["mailId"];
+  const action = payload["action"];
+  const readerId = payload["readerId"];
+  if (typeof requestId !== "string" || requestId.trim().length === 0) {
+    return { ok: false, message: "mailbox.action payload.requestId must be a non-empty string" };
+  }
+  if (typeof mailId !== "string" || mailId.trim().length === 0) {
+    return { ok: false, message: "mailbox.action payload.mailId must be a non-empty string" };
+  }
+  if (typeof action !== "string" || !MAILBOX_ACTIONS.has(action)) {
+    return { ok: false, message: "mailbox.action payload.action must be a supported action" };
+  }
+  if (typeof readerId !== "string" || readerId.trim().length === 0) {
+    return { ok: false, message: "mailbox.action payload.readerId must be a non-empty string" };
+  }
+  return {
+    ok: true,
+    value: {
+      requestId: requestId.trim(),
+      mailId: mailId.trim(),
+      action,
+      readerId: readerId.trim()
+    }
+  };
+}
 var MAILBOX_SEND_TYPES = /* @__PURE__ */ new Set([
   "note",
   "ask",
@@ -402,6 +492,7 @@ function validateMailboxSendPayload(payload) {
     return { ok: false, message: "mailbox.send payload must be an object" };
   }
   const requestId = payload["requestId"];
+  const rawFrom = payload["from"];
   const rawTo = payload["to"];
   const rawType = payload["type"];
   const rawAudience = payload["audience"];
@@ -412,6 +503,9 @@ function validateMailboxSendPayload(payload) {
   if (typeof requestId !== "string" || requestId.trim().length === 0) {
     return { ok: false, message: "mailbox.send payload.requestId must be a non-empty string" };
   }
+  if (rawFrom !== void 0 && (typeof rawFrom !== "string" || rawFrom.trim().length === 0)) {
+    return { ok: false, message: "mailbox.send payload.from must be a non-empty string when provided" };
+  }
   if (typeof rawTo !== "string" || rawTo.trim().length === 0) {
     return { ok: false, message: "mailbox.send payload.to must be a non-empty string" };
   }
@@ -448,6 +542,7 @@ function validateMailboxSendPayload(payload) {
     ok: true,
     value: {
       requestId: requestId.trim(),
+      ...rawFrom !== void 0 ? { from: rawFrom.trim() } : {},
       to,
       type,
       audience: rawAudience,
@@ -737,8 +832,8 @@ function validateShellOpenPayload(payload) {
   if (!isRecord2(payload)) {
     return { ok: false, message: "shell.open payload must be an object with string path" };
   }
-  const path29 = payload["path"];
-  if (typeof path29 !== "string" || path29.trim().length === 0) {
+  const path30 = payload["path"];
+  if (typeof path30 !== "string" || path30.trim().length === 0) {
     return { ok: false, message: "shell.open payload.path must be a non-empty string" };
   }
   const target = payload["target"];
@@ -751,7 +846,7 @@ function validateShellOpenPayload(payload) {
   return {
     ok: true,
     value: {
-      path: path29,
+      path: path30,
       ...target !== void 0 ? { target } : {}
     }
   };
@@ -760,14 +855,14 @@ function validateGitDiffPayload(payload) {
   if (!isRecord2(payload)) {
     return { ok: false, message: "git.diff payload must be an object" };
   }
-  const path29 = payload["path"];
-  if (path29 === void 0 || path29 === null) {
+  const path30 = payload["path"];
+  if (path30 === void 0 || path30 === null) {
     return { ok: true, value: { path: "" } };
   }
-  if (typeof path29 !== "string") {
+  if (typeof path30 !== "string") {
     return { ok: false, message: "git.diff payload.path must be a string when provided" };
   }
-  return { ok: true, value: { path: path29 } };
+  return { ok: true, value: { path: path30 } };
 }
 function validateProjectsAddPayload(payload) {
   if (!isRecord2(payload)) {
@@ -803,6 +898,58 @@ function validateProjectsSelectPayload(payload) {
     value: { root, ...typeof name2 === "string" ? { name: name2 } : {} }
   };
 }
+var MCP_MAX_STRING = 4096;
+var MCP_MAX_ARRAY = 256;
+function isStringArray(value, max = MCP_MAX_ARRAY) {
+  return Array.isArray(value) && value.length <= max && value.every((item) => typeof item === "string" && item.length <= MCP_MAX_STRING);
+}
+function isStringRecord(value) {
+  if (!isRecord2(value)) return false;
+  const entries = Object.entries(value);
+  if (entries.length > MCP_MAX_ARRAY) return false;
+  return entries.every(
+    ([key, item]) => typeof key === "string" && key.length <= MCP_MAX_STRING && typeof item === "string" && item.length <= MCP_MAX_STRING
+  );
+}
+function validateMcpServerPayload(payload, label) {
+  if (!isRecord2(payload)) {
+    return { ok: false, message: `${label} payload must be an object` };
+  }
+  const name2 = payload["name"];
+  if (typeof name2 !== "string" || name2.trim().length === 0 || name2.length > MCP_MAX_STRING) {
+    return { ok: false, message: `${label} payload.name must be a non-empty string` };
+  }
+  for (const key of ["description", "command", "url", "transport", "permission"]) {
+    const value = payload[key];
+    if (value !== void 0 && (typeof value !== "string" || value.length > MCP_MAX_STRING)) {
+      if (!(key === "transport" && isRecord2(value))) {
+        return { ok: false, message: `${label} payload.${key} must be a string` };
+      }
+    }
+  }
+  for (const key of ["enabled", "lazy"]) {
+    const value = payload[key];
+    if (value !== void 0 && typeof value !== "boolean") {
+      return { ok: false, message: `${label} payload.${key} must be a boolean` };
+    }
+  }
+  for (const key of ["args", "allowedTools", "passthroughEnv"]) {
+    const value = payload[key];
+    if (value !== void 0 && !isStringArray(value)) {
+      return { ok: false, message: `${label} payload.${key} must be an array of strings` };
+    }
+  }
+  for (const key of ["env", "headers"]) {
+    const value = payload[key];
+    if (value !== void 0 && !isStringRecord(value)) {
+      return {
+        ok: false,
+        message: `${label} payload.${key} must be an object of string values`
+      };
+    }
+  }
+  return { ok: true, value: payload };
+}
 
 // src/server/prefs-handlers.ts
 function sendResult(ctx, ws, success, message) {
@@ -839,6 +986,9 @@ function handlePrefsUpdate(ctx, ws, input) {
   const payload = parsed.value.prefs;
   for (const [key, value] of Object.entries(payload)) ctx.meta[key] = value;
   void ctx.persist(payload);
+  if (typeof payload["autonomy"] === "string") {
+    ctx.setAutonomy?.(payload["autonomy"]);
+  }
   if (typeof payload["yolo"] === "boolean") {
     ctx.setYolo?.(payload["yolo"]);
     if (payload["yolo"]) resolveYoloEligiblePendingConfirms(ctx.pendingConfirms);
@@ -875,6 +1025,7 @@ function handleAutonomySwitch(ctx, ws, mode) {
 
 // src/server/ws-utils.ts
 import { randomBytes } from "node:crypto";
+import { scrubErrorDetail } from "@wrongstack/core/security";
 import { WebSocket } from "ws";
 var WEBUI_WS_MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
 function sendSerialized(ws, data) {
@@ -912,7 +1063,7 @@ function sendResult2(ws, success, message) {
   send(ws, { type: "key.operation_result", payload: { success, message } });
 }
 function errMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+  return scrubErrorDetail(err);
 }
 function generateAuthToken() {
   return randomBytes(16).toString("hex");
@@ -1205,7 +1356,16 @@ import * as path from "node:path";
 import { resolveIndexDir } from "@wrongstack/tools/codebase-index/index";
 var DB_FILE = "index.db";
 var MAX_CACHE_ENTRIES = 128;
+var MAX_CACHE_BODY_CHARS = 4 * 1024 * 1024;
+var MAX_CACHE_TOTAL_CHARS = 16 * 1024 * 1024;
 var cache = /* @__PURE__ */ new Map();
+var cacheChars = 0;
+function deleteCachedCodemapBody(key) {
+  const entry = cache.get(key);
+  if (!entry) return false;
+  cacheChars = Math.max(0, cacheChars - entry.body.length);
+  return cache.delete(key);
+}
 function indexDbVersion(projectRoot, indexDir) {
   try {
     const dir = resolveIndexDir(projectRoot, indexDir);
@@ -1222,7 +1382,7 @@ function getCachedCodemapBody(key, version) {
   const entry = cache.get(key);
   if (!entry) return void 0;
   if (entry.version !== version) {
-    cache.delete(key);
+    deleteCachedCodemapBody(key);
     return void 0;
   }
   cache.delete(key);
@@ -1230,16 +1390,19 @@ function getCachedCodemapBody(key, version) {
   return entry.body;
 }
 function setCachedCodemapBody(key, version, body) {
-  if (cache.has(key)) cache.delete(key);
+  if (cache.has(key)) deleteCachedCodemapBody(key);
+  if (body.length > MAX_CACHE_BODY_CHARS) return;
   cache.set(key, { version, body });
-  while (cache.size > MAX_CACHE_ENTRIES) {
+  cacheChars += body.length;
+  while (cache.size > MAX_CACHE_ENTRIES || cacheChars > MAX_CACHE_TOTAL_CHARS) {
     const oldest = cache.keys().next().value;
     if (oldest === void 0) break;
-    cache.delete(oldest);
+    deleteCachedCodemapBody(oldest);
   }
 }
 function clearCodemapGraphCache() {
   cache.clear();
+  cacheChars = 0;
 }
 
 // src/server/codebase-indexing.ts
@@ -1529,6 +1692,8 @@ var CollaborationWebSocketHandler = class {
     for (const off of this.offs) off();
     this.offs.length = 0;
     this.stopBroadcast();
+    this.clients.clear();
+    this.bySession.clear();
   }
   // ── Inbound client messages ────────────────────────────────────────────
   /**
@@ -1588,9 +1753,7 @@ var CollaborationWebSocketHandler = class {
     if (activeSessionId !== void 0 && sessionId !== activeSessionId) {
       this.send(
         ws,
-        this.errorMessage(
-          `collab.join sessionId mismatch (active: ${activeSessionId})`
-        )
+        this.errorMessage(`collab.join sessionId mismatch (active: ${activeSessionId})`)
       );
       return;
     }
@@ -1601,26 +1764,19 @@ var CollaborationWebSocketHandler = class {
     if (role === "controller" && !this.bus) {
       this.send(
         ws,
-        this.errorMessage(
-          `role 'controller' is not available: server has no CollaborationBus`
-        )
+        this.errorMessage(`role 'controller' is not available: server has no CollaborationBus`)
       );
       return;
     }
     if (role === "annotator" && !this.annotations) {
       this.send(
         ws,
-        this.errorMessage(
-          `role 'annotator' is not available: server has no annotations store`
-        )
+        this.errorMessage(`role 'annotator' is not available: server has no annotations store`)
       );
       return;
     }
     if (role !== "observer" && this.options.authorizeRole?.({ ws, sessionId, requestedRole: role }) !== true) {
-      this.send(
-        ws,
-        this.errorMessage(`role '${role}' requires explicit server authorization`)
-      );
+      this.send(ws, this.errorMessage(`role '${role}' requires explicit server authorization`));
       return;
     }
     const participant = {
@@ -1649,14 +1805,10 @@ var CollaborationWebSocketHandler = class {
     this.broadcast(sessionId, this.stateMessage(sessionId));
     if (this.reader) {
       this.replayHistory(ws, sessionId).catch((err) => {
-        this.logger.debug?.(
-          `collab: replay failed for ${sessionId}: ${toErrorMessage(err)}`
-        );
+        this.logger.debug?.(`collab: replay failed for ${sessionId}: ${toErrorMessage(err)}`);
       });
     }
-    this.logger.debug?.(
-      `collab: participant ${participant.participantId} joined ${sessionId}`
-    );
+    this.logger.debug?.(`collab: participant ${participant.participantId} joined ${sessionId}`);
   }
   leave(ws) {
     this.handleDisconnect(ws);
@@ -1727,18 +1879,13 @@ var CollaborationWebSocketHandler = class {
     }
     const payload = raw;
     if (!payload?.sessionId || typeof payload.atEventIndex !== "number" || typeof payload.text !== "string") {
-      this.send(
-        ws,
-        this.errorMessage("annotate requires { sessionId, atEventIndex, text }")
-      );
+      this.send(ws, this.errorMessage("annotate requires { sessionId, atEventIndex, text }"));
       return;
     }
     if (payload.sessionId !== participant.sessionId) {
       this.send(
         ws,
-        this.errorMessage(
-          `annotate sessionId mismatch (joined: ${participant.sessionId})`
-        )
+        this.errorMessage(`annotate sessionId mismatch (joined: ${participant.sessionId})`)
       );
       return;
     }
@@ -1765,12 +1912,7 @@ var CollaborationWebSocketHandler = class {
         }
       });
     } catch (err) {
-      this.send(
-        ws,
-        this.errorMessage(
-          `annotation rejected: ${toErrorMessage(err)}`
-        )
-      );
+      this.send(ws, this.errorMessage(`annotation rejected: ${toErrorMessage(err)}`));
     }
   }
   async handleResolve(ws, raw) {
@@ -1786,26 +1928,19 @@ var CollaborationWebSocketHandler = class {
     if (participant.role !== "annotator") {
       this.send(
         ws,
-        this.errorMessage(
-          `resolve requires the 'annotator' role (current: '${participant.role}')`
-        )
+        this.errorMessage(`resolve requires the 'annotator' role (current: '${participant.role}')`)
       );
       return;
     }
     const payload = raw;
     if (!payload?.sessionId || !payload.annotationId) {
-      this.send(
-        ws,
-        this.errorMessage("resolve requires { sessionId, annotationId }")
-      );
+      this.send(ws, this.errorMessage("resolve requires { sessionId, annotationId }"));
       return;
     }
     if (payload.sessionId !== participant.sessionId) {
       this.send(
         ws,
-        this.errorMessage(
-          `resolve sessionId mismatch (joined: ${participant.sessionId})`
-        )
+        this.errorMessage(`resolve sessionId mismatch (joined: ${participant.sessionId})`)
       );
       return;
     }
@@ -1816,10 +1951,7 @@ var CollaborationWebSocketHandler = class {
         resolvedBy: participant.participantId
       });
       if (!updated) {
-        this.send(
-          ws,
-          this.errorMessage(`annotation not found: ${payload.annotationId}`)
-        );
+        this.send(ws, this.errorMessage(`annotation not found: ${payload.annotationId}`));
         return;
       }
       this.broadcast(payload.sessionId, {
@@ -1832,12 +1964,7 @@ var CollaborationWebSocketHandler = class {
         }
       });
     } catch (err) {
-      this.send(
-        ws,
-        this.errorMessage(
-          `resolve failed: ${toErrorMessage(err)}`
-        )
-      );
+      this.send(ws, this.errorMessage(`resolve failed: ${toErrorMessage(err)}`));
     }
   }
   // ── Event subscription (live mirror) ───────────────────────────────────
@@ -1908,9 +2035,7 @@ var CollaborationWebSocketHandler = class {
         seen++;
       }
     } catch (err) {
-      this.logger.debug?.(
-        `collab: session reader rejected ${sessionId}: ${toErrorMessage(err)}`
-      );
+      this.logger.debug?.(`collab: session reader rejected ${sessionId}: ${toErrorMessage(err)}`);
       return;
     }
     const tail2 = seen <= REPLAY_LIMIT ? ring.slice(0, seen) : (
@@ -1992,9 +2117,7 @@ var CollaborationWebSocketHandler = class {
       try {
         sendSerialized(p.ws, data);
       } catch (err) {
-        this.logger.debug?.(
-          `collab broadcast failed: ${toErrorMessage(err)}`
-        );
+        this.logger.debug?.(`collab broadcast failed: ${toErrorMessage(err)}`);
       }
     }
   }
@@ -2021,9 +2144,7 @@ var CollaborationWebSocketHandler = class {
     if (participant.role !== "controller") {
       this.send(
         ws,
-        this.errorMessage(
-          `pause requires the 'controller' role (current: '${participant.role}')`
-        )
+        this.errorMessage(`pause requires the 'controller' role (current: '${participant.role}')`)
       );
       return;
     }
@@ -2068,9 +2189,7 @@ var CollaborationWebSocketHandler = class {
     if (participant.role !== "controller") {
       this.send(
         ws,
-        this.errorMessage(
-          `resume requires the 'controller' role (current: '${participant.role}')`
-        )
+        this.errorMessage(`resume requires the 'controller' role (current: '${participant.role}')`)
       );
       return;
     }
@@ -2168,9 +2287,7 @@ var CollaborationWebSocketHandler = class {
     if (payload.sessionId !== participant.sessionId) {
       this.send(
         ws,
-        this.errorMessage(
-          `inject_tool sessionId mismatch (joined: ${participant.sessionId})`
-        )
+        this.errorMessage(`inject_tool sessionId mismatch (joined: ${participant.sessionId})`)
       );
       return;
     }
@@ -2184,9 +2301,7 @@ var CollaborationWebSocketHandler = class {
     if (!queued) {
       this.send(
         ws,
-        this.errorMessage(
-          `an injection for toolUseId ${payload.toolUseId} is already queued`
-        )
+        this.errorMessage(`an injection for toolUseId ${payload.toolUseId} is already queued`)
       );
       return;
     }
@@ -2782,6 +2897,7 @@ import {
   materializeTokens,
   recordKitChoice,
   recordOverrides,
+  resolveMaterializeTarget,
   resolveSemanticTune,
   runDesignVerify,
   setActiveKit,
@@ -2993,7 +3109,7 @@ async function handleDesignMaterialize(ws, ctx, msg) {
       kitId: active.kit,
       outPath: typeof payload.out === "string" ? payload.out : void 0
     });
-    const abs = path5.join(ctx.projectRoot, result.path);
+    const abs = await resolveMaterializeTarget(result.path, ctx.projectRoot);
     await fs3.mkdir(path5.dirname(abs), { recursive: true });
     await fs3.writeFile(abs, result.content);
     send(ws, {
@@ -3146,7 +3262,29 @@ async function resolveFileInsideProject(projectRoot, filePath) {
   if (!isPathInside(realProjectRoot, realFull)) {
     throw new ToolValidationError2({ message: "Path outside project root", field: "path" });
   }
-  return realFull;
+  const realFinal = await canonicalizeFinalComponent(realFull);
+  if (!isPathInside(realProjectRoot, realFinal)) {
+    throw new ToolValidationError2({ message: "Path outside project root", field: "path" });
+  }
+  return realFinal;
+}
+async function canonicalizeFinalComponent(p) {
+  let stat3;
+  try {
+    stat3 = await fs5.lstat(p);
+  } catch (err) {
+    if (err.code === "ENOENT") return p;
+    throw err;
+  }
+  if (!stat3.isSymbolicLink()) return p;
+  try {
+    return await fs5.realpath(p);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new ToolValidationError2({ message: "Path outside project root", field: "path" });
+    }
+    throw err;
+  }
 }
 function splitParentAndBase(p) {
   const base = path7.basename(p);
@@ -4179,13 +4317,12 @@ function createConversationOperations(ctx) {
     },
     ping: (ws) => ctx.send(ws, { type: "pong", payload: {} }),
     confirmTool: (_ws, msg) => {
-      const requested = requestedSessionId(msg);
-      const current2 = ctx.getSessionId();
-      if (requested && current2 && requested !== current2) return;
       const { id, decision } = msg.payload ?? {};
       if (typeof id !== "string") return;
       const confirm = ctx.pendingConfirms.get(id);
       if (!confirm) return;
+      const claimedSession = requestedSessionId(msg) ?? ctx.getSessionId();
+      if (confirm.sessionId !== void 0 && confirm.sessionId !== claimedSession) return;
       ctx.pendingConfirms.delete(id);
       confirm.resolve(decision);
     }
@@ -4194,7 +4331,17 @@ function createConversationOperations(ctx) {
 
 // src/server/context-editor.ts
 import { createHash } from "node:crypto";
-import { repairToolUseAdjacency } from "@wrongstack/core/utils";
+import net from "node:net";
+import {
+  ALLOWED_IMAGE_MEDIA_TYPES,
+  base64DecodedBytes,
+  isAllowedImageMediaType,
+  isPrivateIPv4,
+  isPrivateIPv6,
+  isValidImageBase64,
+  MAX_INCOMING_IMAGE_BYTES,
+  repairToolUseAdjacency
+} from "@wrongstack/core/utils";
 
 // src/server/token-estimator.ts
 function estimateTokens(s) {
@@ -4258,6 +4405,40 @@ var REVISION_PREFIX = "wrongstack-context-editor-v1\0";
 var MAX_MESSAGE_COUNT_GROWTH = 10;
 var MAX_PAYLOAD_BYTES = 16 * 1024 * 1024;
 var MAX_STRING_LENGTH = 8 * 1024 * 1024;
+var MAX_IMAGE_URL_LENGTH = 2048;
+function imageUrlRejectionReason(url) {
+  if (url.length > MAX_IMAGE_URL_LENGTH) {
+    return `image.source.url exceeds ${MAX_IMAGE_URL_LENGTH} characters.`;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "image.source.url must be an absolute URL.";
+  }
+  if (parsed.protocol !== "https:") {
+    return `image.source.url must use https (got "${parsed.protocol}").`;
+  }
+  if (parsed.username !== "" || parsed.password !== "") {
+    return "image.source.url must not embed credentials.";
+  }
+  const host = parsed.hostname.startsWith("[") && parsed.hostname.endsWith("]") ? parsed.hostname.slice(1, -1) : parsed.hostname;
+  const bareHost = host.endsWith(".") ? host.slice(0, -1) : host;
+  if (bareHost === "") {
+    return "image.source.url must include a hostname.";
+  }
+  if (bareHost === "localhost" || bareHost.endsWith(".localhost")) {
+    return "image.source.url must not target localhost.";
+  }
+  const family = net.isIP(bareHost);
+  if (family === 4 && isPrivateIPv4(bareHost)) {
+    return `image.source.url must not target a private or loopback address ("${bareHost}").`;
+  }
+  if (family === 6 && isPrivateIPv6(bareHost)) {
+    return `image.source.url must not target a private or loopback address ("${bareHost}").`;
+  }
+  return void 0;
+}
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -4288,8 +4469,8 @@ function jsonByteLength(value) {
     return MAX_PAYLOAD_BYTES + 1;
   }
 }
-function error(errors, path29, code, message) {
-  errors.push({ path: path29, code, message });
+function error(errors, path30, code, message) {
+  errors.push({ path: path30, code, message });
 }
 function isMessageRole(value) {
   return value === "user" || value === "assistant" || value === "system";
@@ -4297,25 +4478,25 @@ function isMessageRole(value) {
 function isPlainJsonObject(value) {
   return isRecord3(value);
 }
-function validateCacheControl(value, path29, errors) {
+function validateCacheControl(value, path30, errors) {
   if (value === void 0) return void 0;
   if (!isRecord3(value) || value["type"] !== "ephemeral") {
-    error(errors, path29, "INVALID_CACHE_CONTROL", 'cache_control must be { type: "ephemeral" }.');
+    error(errors, path30, "INVALID_CACHE_CONTROL", 'cache_control must be { type: "ephemeral" }.');
     return void 0;
   }
   return { type: "ephemeral" };
 }
-function validateProviderMeta(value, path29, errors) {
+function validateProviderMeta(value, path30, errors) {
   if (value === void 0) return void 0;
   if (!isPlainJsonObject(value)) {
-    error(errors, path29, "INVALID_PROVIDER_META", "providerMeta must be a JSON object.");
+    error(errors, path30, "INVALID_PROVIDER_META", "providerMeta must be a JSON object.");
     return void 0;
   }
   return value;
 }
-function validateBlock(value, path29, errors) {
+function validateBlock(value, path30, errors) {
   if (!isRecord3(value)) {
-    error(errors, path29, "INVALID_BLOCK", "Content block must be an object.");
+    error(errors, path30, "INVALID_BLOCK", "Content block must be an object.");
     return void 0;
   }
   const type = value["type"];
@@ -4323,14 +4504,18 @@ function validateBlock(value, path29, errors) {
     case "text": {
       const text = value["text"];
       if (typeof text !== "string") {
-        error(errors, `${path29}/text`, "INVALID_TEXT", "Text block text must be a string.");
+        error(errors, `${path30}/text`, "INVALID_TEXT", "Text block text must be a string.");
         return void 0;
       }
       if (text.length > MAX_STRING_LENGTH) {
-        error(errors, `${path29}/text`, "TEXT_TOO_LARGE", "Text block is too large.");
+        error(errors, `${path30}/text`, "TEXT_TOO_LARGE", "Text block is too large.");
         return void 0;
       }
-      const cacheControl = validateCacheControl(value["cache_control"], `${path29}/cache_control`, errors);
+      const cacheControl = validateCacheControl(
+        value["cache_control"],
+        `${path30}/cache_control`,
+        errors
+      );
       return cacheControl ? { type: "text", text, cache_control: cacheControl } : { type: "text", text };
     }
     case "tool_use": {
@@ -4338,15 +4523,29 @@ function validateBlock(value, path29, errors) {
       const name2 = value["name"];
       const input = value["input"];
       if (typeof id !== "string" || id.length === 0) {
-        error(errors, `${path29}/id`, "INVALID_TOOL_USE_ID", "tool_use.id must be a non-empty string.");
+        error(
+          errors,
+          `${path30}/id`,
+          "INVALID_TOOL_USE_ID",
+          "tool_use.id must be a non-empty string."
+        );
       }
       if (typeof name2 !== "string" || name2.length === 0) {
-        error(errors, `${path29}/name`, "INVALID_TOOL_NAME", "tool_use.name must be a non-empty string.");
+        error(
+          errors,
+          `${path30}/name`,
+          "INVALID_TOOL_NAME",
+          "tool_use.name must be a non-empty string."
+        );
       }
       if (!isPlainJsonObject(input)) {
-        error(errors, `${path29}/input`, "INVALID_TOOL_INPUT", "tool_use.input must be an object.");
+        error(errors, `${path30}/input`, "INVALID_TOOL_INPUT", "tool_use.input must be an object.");
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path29}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(
+        value["providerMeta"],
+        `${path30}/providerMeta`,
+        errors
+      );
       if (typeof id !== "string" || id.length === 0 || typeof name2 !== "string" || name2.length === 0 || !isPlainJsonObject(input)) {
         return void 0;
       }
@@ -4358,20 +4557,46 @@ function validateBlock(value, path29, errors) {
       const content = value["content"];
       const isError = value["is_error"];
       if (typeof toolUseId !== "string" || toolUseId.length === 0) {
-        error(errors, `${path29}/tool_use_id`, "INVALID_TOOL_RESULT_ID", "tool_result.tool_use_id must be a non-empty string.");
+        error(
+          errors,
+          `${path30}/tool_use_id`,
+          "INVALID_TOOL_RESULT_ID",
+          "tool_result.tool_use_id must be a non-empty string."
+        );
       }
       if (name2 !== void 0 && typeof name2 !== "string") {
-        error(errors, `${path29}/name`, "INVALID_TOOL_RESULT_NAME", "tool_result.name must be a string.");
+        error(
+          errors,
+          `${path30}/name`,
+          "INVALID_TOOL_RESULT_NAME",
+          "tool_result.name must be a string."
+        );
       }
       if (typeof content !== "string") {
-        error(errors, `${path29}/content`, "INVALID_TOOL_RESULT_CONTENT", "tool_result.content must be a string.");
+        error(
+          errors,
+          `${path30}/content`,
+          "INVALID_TOOL_RESULT_CONTENT",
+          "tool_result.content must be a string."
+        );
       } else if (content.length > MAX_STRING_LENGTH) {
-        error(errors, `${path29}/content`, "TOOL_RESULT_TOO_LARGE", "tool_result.content is too large.");
+        error(
+          errors,
+          `${path30}/content`,
+          "TOOL_RESULT_TOO_LARGE",
+          "tool_result.content is too large."
+        );
       }
       if (isError !== void 0 && typeof isError !== "boolean") {
-        error(errors, `${path29}/is_error`, "INVALID_TOOL_RESULT_ERROR", "tool_result.is_error must be boolean.");
+        error(
+          errors,
+          `${path30}/is_error`,
+          "INVALID_TOOL_RESULT_ERROR",
+          "tool_result.is_error must be boolean."
+        );
       }
-      if (typeof toolUseId !== "string" || toolUseId.length === 0 || typeof content !== "string") return void 0;
+      if (typeof toolUseId !== "string" || toolUseId.length === 0 || typeof content !== "string")
+        return void 0;
       return {
         type: "tool_result",
         tool_use_id: toolUseId,
@@ -4383,33 +4608,97 @@ function validateBlock(value, path29, errors) {
     case "image": {
       const source = value["source"];
       if (!isRecord3(source)) {
-        error(errors, `${path29}/source`, "INVALID_IMAGE_SOURCE", "image.source must be an object.");
+        error(errors, `${path30}/source`, "INVALID_IMAGE_SOURCE", "image.source must be an object.");
         return void 0;
       }
       const sourceType = source["type"];
       if (sourceType !== "base64" && sourceType !== "url") {
-        error(errors, `${path29}/source/type`, "INVALID_IMAGE_SOURCE_TYPE", "image.source.type must be base64 or url.");
+        error(
+          errors,
+          `${path30}/source/type`,
+          "INVALID_IMAGE_SOURCE_TYPE",
+          "image.source.type must be base64 or url."
+        );
         return void 0;
       }
       const mediaType = source["media_type"];
       const data = source["data"];
       const url = source["url"];
       if (mediaType !== void 0 && typeof mediaType !== "string") {
-        error(errors, `${path29}/source/media_type`, "INVALID_IMAGE_MEDIA_TYPE", "image.source.media_type must be a string.");
+        error(
+          errors,
+          `${path30}/source/media_type`,
+          "INVALID_IMAGE_MEDIA_TYPE",
+          "image.source.media_type must be a string."
+        );
+        return void 0;
       }
-      if (data !== void 0 && typeof data !== "string") {
-        error(errors, `${path29}/source/data`, "INVALID_IMAGE_DATA", "image.source.data must be a string.");
+      if (typeof mediaType === "string" && !isAllowedImageMediaType(mediaType)) {
+        error(
+          errors,
+          `${path30}/source/media_type`,
+          "UNSUPPORTED_IMAGE_MEDIA_TYPE",
+          `image.source.media_type must be one of: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}.`
+        );
+        return void 0;
+      }
+      if (sourceType === "base64") {
+        if (typeof data !== "string" || data.length === 0) {
+          error(
+            errors,
+            `${path30}/source/data`,
+            "INVALID_IMAGE_DATA",
+            "image.source.data must be a non-empty string for a base64 source."
+          );
+          return void 0;
+        }
+        if (!isValidImageBase64(data)) {
+          error(
+            errors,
+            `${path30}/source/data`,
+            "INVALID_IMAGE_DATA",
+            "image.source.data is not valid base64."
+          );
+          return void 0;
+        }
+        if (base64DecodedBytes(data) > MAX_INCOMING_IMAGE_BYTES) {
+          error(
+            errors,
+            `${path30}/source/data`,
+            "IMAGE_TOO_LARGE",
+            `image.source.data exceeds the ${MAX_INCOMING_IMAGE_BYTES / (1024 * 1024)} MB limit.`
+          );
+          return void 0;
+        }
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            ...typeof mediaType === "string" ? { media_type: mediaType } : {},
+            data
+          }
+        };
       }
-      if (url !== void 0 && typeof url !== "string") {
-        error(errors, `${path29}/source/url`, "INVALID_IMAGE_URL", "image.source.url must be a string.");
+      if (typeof url !== "string" || url.length === 0) {
+        error(
+          errors,
+          `${path30}/source/url`,
+          "INVALID_IMAGE_URL",
+          "image.source.url must be a non-empty string for a url source."
+        );
+        return void 0;
+      }
+      const urlError = imageUrlRejectionReason(url);
+      if (urlError !== void 0) {
+        error(errors, `${path30}/source/url`, "UNSAFE_IMAGE_URL", urlError);
+        return void 0;
       }
       return {
         type: "image",
         source: {
-          type: sourceType,
+          type: "url",
           ...typeof mediaType === "string" ? { media_type: mediaType } : {},
-          ...typeof data === "string" ? { data } : {},
-          ...typeof url === "string" ? { url } : {}
+          url
         }
       };
     }
@@ -4417,13 +4706,27 @@ function validateBlock(value, path29, errors) {
       const thinking = value["thinking"];
       const signature = value["signature"];
       if (typeof thinking !== "string") {
-        error(errors, `${path29}/thinking`, "INVALID_THINKING", "thinking.thinking must be a string.");
+        error(
+          errors,
+          `${path30}/thinking`,
+          "INVALID_THINKING",
+          "thinking.thinking must be a string."
+        );
         return void 0;
       }
       if (signature !== void 0 && typeof signature !== "string") {
-        error(errors, `${path29}/signature`, "INVALID_THINKING_SIGNATURE", "thinking.signature must be a string.");
+        error(
+          errors,
+          `${path30}/signature`,
+          "INVALID_THINKING_SIGNATURE",
+          "thinking.signature must be a string."
+        );
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path29}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(
+        value["providerMeta"],
+        `${path30}/providerMeta`,
+        errors
+      );
       return {
         type: "thinking",
         thinking,
@@ -4432,7 +4735,12 @@ function validateBlock(value, path29, errors) {
       };
     }
     default:
-      error(errors, `${path29}/type`, "UNKNOWN_BLOCK_TYPE", `Unknown content block type: ${String(type)}`);
+      error(
+        errors,
+        `${path30}/type`,
+        "UNKNOWN_BLOCK_TYPE",
+        `Unknown content block type: ${String(type)}`
+      );
       return void 0;
   }
 }
@@ -4444,45 +4752,65 @@ function validateContextEditorMessages(value, currentMessageCount = 0) {
     return { messages, errors };
   }
   if (value.length > currentMessageCount + MAX_MESSAGE_COUNT_GROWTH) {
-    error(errors, "/messages", "TOO_MANY_MESSAGES", "Context editor is deletion-oriented; proposed message count grew too much.");
+    error(
+      errors,
+      "/messages",
+      "TOO_MANY_MESSAGES",
+      "Context editor is deletion-oriented; proposed message count grew too much."
+    );
   }
   if (jsonByteLength(value) > MAX_PAYLOAD_BYTES) {
     error(errors, "/messages", "PAYLOAD_TOO_LARGE", "Context editor payload is too large.");
   }
   value.forEach((item, index) => {
-    const path29 = `/messages/${index}`;
+    const path30 = `/messages/${index}`;
     if (!isRecord3(item)) {
-      error(errors, path29, "INVALID_MESSAGE", "Message must be an object.");
+      error(errors, path30, "INVALID_MESSAGE", "Message must be an object.");
       return;
     }
     const role = item["role"];
     if (!isMessageRole(role)) {
-      error(errors, `${path29}/role`, "INVALID_ROLE", "Message role must be user, assistant, or system.");
+      error(
+        errors,
+        `${path30}/role`,
+        "INVALID_ROLE",
+        "Message role must be user, assistant, or system."
+      );
       return;
     }
     const rawContent = item["content"];
     let content;
     if (typeof rawContent === "string") {
       if (rawContent.length > MAX_STRING_LENGTH) {
-        error(errors, `${path29}/content`, "CONTENT_TOO_LARGE", "Message content is too large.");
+        error(errors, `${path30}/content`, "CONTENT_TOO_LARGE", "Message content is too large.");
         return;
       }
       content = rawContent;
     } else if (Array.isArray(rawContent)) {
       const blocks = [];
       rawContent.forEach((block, blockIndex) => {
-        const parsed = validateBlock(block, `${path29}/content/${blockIndex}`, errors);
+        const parsed = validateBlock(block, `${path30}/content/${blockIndex}`, errors);
         if (parsed) blocks.push(parsed);
       });
       content = blocks;
     } else {
-      error(errors, `${path29}/content`, "INVALID_CONTENT", "Message content must be a string or content block array.");
+      error(
+        errors,
+        `${path30}/content`,
+        "INVALID_CONTENT",
+        "Message content must be a string or content block array."
+      );
       return;
     }
     const ts = item["ts"];
     if (ts !== void 0) {
       if (typeof ts !== "string" || Number.isNaN(Date.parse(ts))) {
-        error(errors, `${path29}/ts`, "INVALID_TIMESTAMP", "Message ts must be an ISO-like timestamp string.");
+        error(
+          errors,
+          `${path30}/ts`,
+          "INVALID_TIMESTAMP",
+          "Message ts must be an ISO-like timestamp string."
+        );
         return;
       }
     }
@@ -4492,7 +4820,8 @@ function validateContextEditorMessages(value, currentMessageCount = 0) {
 }
 function countBlocks(messages) {
   let total = 0;
-  for (const message of messages) total += Array.isArray(message.content) ? message.content.length : 1;
+  for (const message of messages)
+    total += Array.isArray(message.content) ? message.content.length : 1;
   return total;
 }
 function toolDiagnostics(messages) {
@@ -4556,11 +4885,13 @@ function metricFor(ctx, messages, tools) {
   };
 }
 function buildContextEditorSnapshot(ctx, tools) {
-  const messages = ctx.messages.map((message) => ({
-    role: message.role,
-    content: message.content,
-    ...message.ts ? { ts: message.ts } : {}
-  }));
+  const messages = ctx.messages.map(
+    (message) => ({
+      role: message.role,
+      content: message.content,
+      ...message.ts ? { ts: message.ts } : {}
+    })
+  );
   const breakdown = estimateContextBreakdown({
     systemPrompt: ctx.systemPrompt,
     tools: tools ?? ctx.tools ?? [],
@@ -4605,7 +4936,10 @@ function validateContextEditorProposal(input) {
       validationErrors: [],
       warnings: [],
       repair: emptyRepair,
-      conflict: { code: "RUN_ACTIVE", message: "The agent is currently running. Abort or wait before applying context edits." }
+      conflict: {
+        code: "RUN_ACTIVE",
+        message: "The agent is currently running. Abort or wait before applying context edits."
+      }
     };
   }
   if (input.baseRevision !== currentRevision) {
@@ -4617,7 +4951,10 @@ function validateContextEditorProposal(input) {
       validationErrors: [],
       warnings: [],
       repair: emptyRepair,
-      conflict: { code: "CONTEXT_REVISION_CONFLICT", message: "Context changed while the editor was open. Reload before applying." }
+      conflict: {
+        code: "CONTEXT_REVISION_CONFLICT",
+        message: "Context changed while the editor was open. Reload before applying."
+      }
     };
   }
   const parsed = validateContextEditorMessages(input.messages, input.ctx.messages.length);
@@ -4700,6 +5037,7 @@ async function applyContextEditorProposal(input) {
 }
 
 // src/server/connection-lifecycle.ts
+var RATE_LIMIT_EXEMPT_TYPES = /* @__PURE__ */ new Set(["ping", "pong"]);
 function createConnectionLifecycle(options) {
   const rateLimitMax = options.rateLimitMax ?? 0;
   const rateLimitWindowMs = options.rateLimitWindowMs ?? 6e4;
@@ -4770,25 +5108,31 @@ function createConnectionLifecycle(options) {
     }
     let messageCount = 0;
     let rateWindowResetAt = Date.now() + rateLimitWindowMs;
-    ws.on("message", async (data) => {
-      if (rateLimitMax > 0) {
-        const now = Date.now();
-        if (now > rateWindowResetAt) {
-          messageCount = 0;
-          rateWindowResetAt = now + rateLimitWindowMs;
-        }
-        if (++messageCount > rateLimitMax) {
-          options.send(ws, {
-            type: "error",
-            payload: options.sessionPayload({
-              phase: "rate_limit",
-              message: options.rateLimitMessage ?? "Too many messages. Please wait."
-            })
-          });
-          return;
-        }
+    let rateLimitNotified = false;
+    const chargeRateLimit = () => {
+      if (!Number.isFinite(rateLimitMax) || rateLimitMax <= 0) return true;
+      const now = Date.now();
+      if (now > rateWindowResetAt) {
+        messageCount = 0;
+        rateWindowResetAt = now + rateLimitWindowMs;
+        rateLimitNotified = false;
+      }
+      if (++messageCount <= rateLimitMax) return true;
+      if (!rateLimitNotified) {
+        rateLimitNotified = true;
+        options.send(ws, {
+          type: "error",
+          payload: options.sessionPayload({
+            phase: "rate_limit",
+            message: options.rateLimitMessage ?? "Too many messages. Please wait."
+          })
+        });
       }
+      return false;
+    };
+    ws.on("message", async (data) => {
       const decoded = options.decode(data.toString());
+      if (!decoded.ok && !chargeRateLimit()) return;
       if (!decoded.ok) {
         const eventName = decoded.issue.message === "Protocol frame is not valid JSON" ? "webui_server.message_parse_failed" : "webui_server.message_rejected";
         const level = decoded.issue.code === "unsafe_key" || decoded.issue.code === "too_deep" ? "error" : "warn";
@@ -4826,6 +5170,10 @@ function createConnectionLifecycle(options) {
         });
         return;
       }
+      const messageType = decoded.message.type;
+      if ((typeof messageType !== "string" || !RATE_LIMIT_EXEMPT_TYPES.has(messageType)) && !chargeRateLimit()) {
+        return;
+      }
       try {
         await options.dispatch(ws, client, decoded.message);
       } catch (error2) {
@@ -4866,10 +5214,16 @@ import {
   MailboxProjectServerConnection
 } from "@wrongstack/core/coordination";
 import { resolveWstackPaths as resolveWstackPaths2 } from "@wrongstack/core/utils";
-import { getKanbanServerConnection } from "@wrongstack/kanban";
+import {
+  closeKanbanServerConnections,
+  getKanbanServerConnection,
+  isKanbanServerAvailable
+} from "@wrongstack/kanban";
+import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
 import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
 import {
   checkCodebaseIndexServerHealth,
+  ensureCodebaseIndexServer as ensureCodebaseIndexServer2,
   getIndexState,
   resolveProjectIndexDaemonAvailability,
   shutdownCodebaseIndexServer
@@ -4898,7 +5252,8 @@ async function collectConnectionsHealth(options) {
     codebaseIndexHealth(options.projectRoot, options.indexDir),
     sageHealth(options.projectRoot),
     kanbanHealth(options.projectRoot),
-    mailboxHealth(options.projectRoot)
+    mailboxHealth(options.projectRoot),
+    governanceHealth(options.projectRoot)
   ]);
   const required = services.filter((service) => service.required);
   const overall = required.some((service) => service.status === "error") ? "error" : required.some((service) => service.status !== "healthy") ? "degraded" : "healthy";
@@ -5203,6 +5558,42 @@ async function mailboxHealth(projectRoot) {
     connection.close();
   }
 }
+async function governanceHealth(projectRoot) {
+  const startedAt = Date.now();
+  const result = await readGovernanceDaemonOperatorStatus(projectRoot);
+  if (!result.available) {
+    const missing = result.code === "broker_missing";
+    return {
+      id: "governance",
+      label: "Governance control plane",
+      status: missing ? "offline" : "error",
+      required: false,
+      mode: missing ? "compatibility-default-off" : "project-daemon",
+      detail: missing ? "Not active for this project. Existing agent and model execution remains unchanged." : `Read-only governance status is unavailable: ${result.message}`,
+      latencyMs: Date.now() - startedAt,
+      control: "none",
+      ...missing ? {} : { lastError: result.message }
+    };
+  }
+  const { status } = result;
+  return {
+    id: "governance",
+    label: "Governance control plane",
+    status: status.signal.level === "healthy" ? "healthy" : "degraded",
+    required: false,
+    mode: "project-daemon-advisory",
+    detail: `${status.signal.message} Execution continues; no automatic task or model stop.`,
+    ownerPid: status.pid,
+    uptimeMs: Math.max(0, Date.now() - Date.parse(status.startedAt)),
+    latencyMs: Date.now() - startedAt,
+    control: "none",
+    advisory: {
+      code: status.signal.code,
+      operatorAction: status.signal.operatorAction,
+      executionDisposition: status.signal.executionDisposition
+    }
+  };
+}
 function failureService(id, label, required, mode, error2, latencyMs) {
   const message = error2 instanceof Error ? error2.message : String(error2);
   return {
@@ -5420,15 +5811,15 @@ async function handleGitChanges(ws, projectRoot) {
         if (!m) continue;
         const added = m[1] === "-" ? 0 : Number(m[1]);
         const deleted = m[2] === "-" ? 0 : Number(m[2]);
-        let path29 = m[3] ?? "";
-        if (path29 === "") {
+        let path30 = m[3] ?? "";
+        if (path30 === "") {
           i += 1;
-          path29 = parts[i + 1] ?? parts[i] ?? "";
+          path30 = parts[i + 1] ?? parts[i] ?? "";
           i += 1;
         }
-        if (!path29) continue;
-        const prev = counts.get(path29) ?? { added: 0, deleted: 0 };
-        counts.set(path29, { added: prev.added + added, deleted: prev.deleted + deleted });
+        if (!path30) continue;
+        const prev = counts.get(path30) ?? { added: 0, deleted: 0 };
+        counts.set(path30, { added: prev.added + added, deleted: prev.deleted + deleted });
       }
     };
     parseNumstat(unstagedNumstat);
@@ -5440,7 +5831,7 @@ async function handleGitChanges(ws, projectRoot) {
       if (!rec || rec.length < 3) continue;
       const x = rec[0] ?? " ";
       const y = rec[1] ?? " ";
-      const path29 = rec.slice(3);
+      const path30 = rec.slice(3);
       const isRename = x === "R" || x === "C" || y === "R" || y === "C";
       if (isRename) i += 1;
       let status;
@@ -5452,13 +5843,13 @@ async function handleGitChanges(ws, projectRoot) {
       else if (x === "D" || y === "D") status = "D";
       else status = "M";
       const staged = x !== " " && x !== "?";
-      let added = counts.get(path29)?.added ?? 0;
-      let deleted = counts.get(path29)?.deleted ?? 0;
+      let added = counts.get(path30)?.added ?? 0;
+      let deleted = counts.get(path30)?.deleted ?? 0;
       if (status === "?") {
         added = 0;
         deleted = 0;
       }
-      files.push({ path: path29, status, added, deleted, staged });
+      files.push({ path: path30, status, added, deleted, staged });
     }
     send(ws, { type: "git.changes", payload: { files } });
   } catch (err) {
@@ -5469,10 +5860,10 @@ async function handleGitChanges(ws, projectRoot) {
   }
 }
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
-async function handleGitDiff(ws, projectRoot, path29) {
+async function handleGitDiff(ws, projectRoot, path30) {
   const cwd = projectRoot || void 0;
-  const reply2 = (extra) => send(ws, { type: "git.diff", payload: { path: path29, ...extra } });
-  if (!path29 || path29.includes("\0") || path29.includes("..") || nodePath.isAbsolute(path29)) {
+  const reply2 = (extra) => send(ws, { type: "git.diff", payload: { path: path30, ...extra } });
+  if (!path30 || path30.includes("\0") || path30.includes("..") || nodePath.isAbsolute(path30)) {
     reply2({ oldText: "", newText: "", error: "invalid path" });
     return;
   }
@@ -5480,10 +5871,10 @@ async function handleGitDiff(ws, projectRoot, path29) {
     const git = makeGit(cwd);
     const { readFile: readFile11 } = await import("node:fs/promises");
     const { join: join15 } = await import("node:path");
-    const oldText = await git(["show", `HEAD:${path29}`]);
+    const oldText = await git(["show", `HEAD:${path30}`]);
     let newText = "";
     try {
-      const abs = cwd ? join15(cwd, path29) : path29;
+      const abs = cwd ? join15(cwd, path30) : path30;
       const buf = await readFile11(abs);
       if (buf.includes(0)) {
         reply2({ oldText: "", newText: "", binary: true });
@@ -5545,10 +5936,7 @@ async function handleGoalSnapshotRoute(ws, msg, handlers) {
 }
 
 // src/server/goal-ws-handler.ts
-import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
-import {
-  assignNickname
-} from "@wrongstack/core/coordination";
+import { assignNickname } from "@wrongstack/core/coordination";
 import {
   GoalAssessor,
   GoalPlanner,
@@ -5556,6 +5944,7 @@ import {
   PhaseOrchestrator,
   PhaseStore
 } from "@wrongstack/core/goal";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 import { WorktreeManager } from "@wrongstack/core/worktree";
 
 // src/server/git-process.ts
@@ -5592,12 +5981,7 @@ function deriveTitle(goal) {
   return trimmed || "Goal";
 }
 async function commitsSince(cwd, baseSha, branch) {
-  const output = await gitStdout(cwd, [
-    "log",
-    "--reverse",
-    "--format=%H",
-    `${baseSha}..${branch}`
-  ]);
+  const output = await gitStdout(cwd, ["log", "--reverse", "--format=%H", `${baseSha}..${branch}`]);
   if (output === null) return [];
   return output.split("\n").map((s) => s.trim()).filter(Boolean);
 }
@@ -5648,6 +6032,20 @@ var GoalWebSocketHandler = class {
     ws.on("error", () => this.clients.delete(client));
     this.sendState(client);
   }
+  /** Release timers, in-flight work, and socket references owned by this host. */
+  dispose() {
+    this.stopping = true;
+    this.abort?.abort();
+    this.abort = null;
+    this.assessAbort?.abort();
+    this.assessAbort = null;
+    this.orchestrator?.stop();
+    this.orchestrator = null;
+    this.stopBroadcast();
+    this.clients.clear();
+    this.usedNicknames.clear();
+    this.worktrees = null;
+  }
   async handleMessage(ws, msg) {
     switch (msg.type) {
       case "goal.assess":
@@ -5695,7 +6093,8 @@ var GoalWebSocketHandler = class {
       }
       case "goal.assignTask": {
         const { taskId, agentId, agentName } = msg.payload;
-        if (this.orchestrator?.setTaskAssignee(taskId, agentId, agentName)) this.afterBoardMutation();
+        if (this.orchestrator?.setTaskAssignee(taskId, agentId, agentName))
+          this.afterBoardMutation();
         break;
       }
       case "goal.addTask": {
@@ -5740,7 +6139,10 @@ var GoalWebSocketHandler = class {
             this.graph = graph;
             this.broadcast({ type: "goal.state", payload: this.buildState() });
           } else {
-            this.broadcast({ type: "goal.error", payload: { message: `Graph not found: ${graphId}` } });
+            this.broadcast({
+              type: "goal.error",
+              payload: { message: `Graph not found: ${graphId}` }
+            });
           }
         }
         break;
@@ -5763,10 +6165,13 @@ var GoalWebSocketHandler = class {
     const mySeq = ++this.assessSeq;
     const sendResult7 = (result) => {
       if (mySeq !== this.assessSeq) return;
-      sendSerialized(ws, JSON.stringify({
-        type: "goal.assess.result",
-        payload: { ...result, reqSeq: seq }
-      }));
+      sendSerialized(
+        ws,
+        JSON.stringify({
+          type: "goal.assess.result",
+          payload: { ...result, reqSeq: seq }
+        })
+      );
     };
     if (!goal.trim()) {
       sendResult7({
@@ -5812,15 +6217,24 @@ var GoalWebSocketHandler = class {
     const multiBoard = payload?.multiBoard ?? false;
     const verifyTasks = payload?.verifyTasks ?? false;
     const chimeraReview = payload?.chimeraReview ?? false;
-    this.abort = new AbortController();
+    const runAbort = new AbortController();
+    this.abort = runAbort;
     this.stopping = false;
-    const phases = Array.isArray(payload?.phases) ? payload.phases : await this.planPhases(goal, this.abort.signal);
-    if (this.stopping || this.abort.signal.aborted) {
+    const phases = Array.isArray(payload?.phases) ? payload.phases : await this.planPhases(goal, runAbort.signal);
+    if (this.stopping || runAbort.signal.aborted) {
       this.broadcast({ type: "goal.stopped", payload: { title } });
       return;
     }
     this.logger.info(`[Goal] Starting: ${title}`);
-    const graph = await new PhaseGraphBuilder({ title, description: goal, phases, autonomous, multiBoard, verifyTasks, chimeraReview }).build();
+    const graph = await new PhaseGraphBuilder({
+      title,
+      description: goal,
+      phases,
+      autonomous,
+      multiBoard,
+      verifyTasks,
+      chimeraReview
+    }).build();
     this.graph = graph;
     await this.store.save(graph);
     const useWorktrees = payload?.worktrees ?? process.env["WRONGSTACK_GOAL_WORKTREES"] !== "0";
@@ -5839,9 +6253,10 @@ var GoalWebSocketHandler = class {
       maybeVerify.verifyPhase = (async (phase, env) => {
         const cwd = env?.cwd ?? this.projectRoot;
         try {
-          const { exec } = await import("node:child_process");
+          const { execFile: execFile2 } = await import("node:child_process");
           const result = await new Promise((resolve15) => {
-            exec("npx tsc --noEmit", { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
+            const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx";
+            execFile2(npxCommand, ["tsc", "--noEmit"], { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
               if (err && err.code === "ENOENT") {
                 resolve15("[verify] tsc not found \u2014 skipping");
                 return;
@@ -5983,11 +6398,41 @@ Run npx tsc --noEmit to verify the fix. Output the fixed file paths.`;
   /** Generic fallback phases when the LLM planner produces nothing usable. */
   defaultPhases() {
     return [
-      { name: "Discovery", description: "Requirements gathering", priority: "high", estimateHours: 2, parallelizable: false },
-      { name: "Design", description: "Architecture and design", priority: "critical", estimateHours: 4, parallelizable: false },
-      { name: "Implementation", description: "Core development", priority: "critical", estimateHours: 12, parallelizable: false },
-      { name: "Testing", description: "Unit and integration tests", priority: "high", estimateHours: 6, parallelizable: true },
-      { name: "Deployment", description: "Deploy to production", priority: "medium", estimateHours: 2, parallelizable: false }
+      {
+        name: "Discovery",
+        description: "Requirements gathering",
+        priority: "high",
+        estimateHours: 2,
+        parallelizable: false
+      },
+      {
+        name: "Design",
+        description: "Architecture and design",
+        priority: "critical",
+        estimateHours: 4,
+        parallelizable: false
+      },
+      {
+        name: "Implementation",
+        description: "Core development",
+        priority: "critical",
+        estimateHours: 12,
+        parallelizable: false
+      },
+      {
+        name: "Testing",
+        description: "Unit and integration tests",
+        priority: "high",
+        estimateHours: 6,
+        parallelizable: true
+      },
+      {
+        name: "Deployment",
+        description: "Deploy to production",
+        priority: "medium",
+        estimateHours: 2,
+        parallelizable: false
+      }
     ];
   }
   /** Plan phases+todos for the goal via the LLM; fall back to defaults on failure.
@@ -6068,8 +6513,10 @@ Type: ${task.type}`;
     try {
       const result_ = await this.agent.run(reviewPrompt);
       if (result_.status === "done" && result_.finalText) {
-        this.logger.info(`[Goal] Chimera review for "${task.title}":
-${result_.finalText.slice(0, 2e3)}`);
+        this.logger.info(
+          `[Goal] Chimera review for "${task.title}":
+${result_.finalText.slice(0, 2e3)}`
+        );
       }
     } catch (err) {
       this.logger.warn(`[Goal] Chimera review failed for "${task.title}": ${toErrorMessage2(err)}`);
@@ -6122,7 +6569,16 @@ ${result_.finalText.slice(0, 2e3)}`);
   }
   buildState(activePhaseId) {
     if (!this.graph) {
-      return { phases: [], tasks: [], overallPercent: 0, autonomous: true, title: "", multiBoard: false, verifyTasks: false, chimeraReview: false };
+      return {
+        phases: [],
+        tasks: [],
+        overallPercent: 0,
+        autonomous: true,
+        title: "",
+        multiBoard: false,
+        verifyTasks: false,
+        chimeraReview: false
+      };
     }
     const phases = Array.from(this.graph.phases.values());
     const currentActiveId = activePhaseId || phases.find((p) => p.status === "running")?.id || phases[0]?.id || "";
@@ -6620,88 +7076,13 @@ async function handleApiAnalyticsSummary(res) {
 }
 
 // src/server/http-server.ts
-import * as fs9 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import * as http from "node:http";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import * as v8 from "node:v8";
+import { sanitizeApiError as sanitizeApiError2 } from "@wrongstack/core/security";
 import { getIndexState as getIndexState2 } from "@wrongstack/tools";
 
-// src/server/codemap-handlers.ts
-import { fileGraphService, packageGraphService, symbolGraphService } from "@wrongstack/tools";
-function sendJsonBody(res, status, body, cacheStatus) {
-  res.writeHead(status, {
-    "Content-Type": "application/json",
-    "X-Codemap-Cache": cacheStatus
-  });
-  res.end(body);
-}
-function sendJson(res, status, data, cacheStatus = "BYPASS") {
-  sendJsonBody(res, status, JSON.stringify(data), cacheStatus);
-}
-async function serveCachedGraph(res, deps2, scope, compute) {
-  try {
-    const version = indexDbVersion(deps2.projectRoot, deps2.indexDir);
-    const key = codemapCacheKey(deps2.projectRoot, deps2.indexDir, scope);
-    const hit = getCachedCodemapBody(key, version);
-    if (hit !== void 0) {
-      sendJsonBody(res, 200, hit, "HIT");
-      return;
-    }
-    const graph = await compute();
-    const body = JSON.stringify(graph);
-    if (version !== "missing") {
-      setCachedCodemapBody(key, version, body);
-    }
-    sendJsonBody(res, 200, body, "MISS");
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    sendJson(res, 503, { error: "CodeMap index unavailable", detail: msg }, "BYPASS");
-  }
-}
-async function handleCodemapPackages(res, deps2) {
-  await serveCachedGraph(
-    res,
-    deps2,
-    "packages",
-    () => packageGraphService({
-      projectRoot: deps2.projectRoot,
-      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
-    })
-  );
-}
-async function handleCodemapFiles(res, deps2, pkg) {
-  if (!pkg) {
-    sendJson(res, 400, { error: 'Missing "package" query parameter' });
-    return;
-  }
-  await serveCachedGraph(
-    res,
-    deps2,
-    `files:${pkg}`,
-    () => fileGraphService({
-      projectRoot: deps2.projectRoot,
-      packageFilter: pkg,
-      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
-    })
-  );
-}
-async function handleCodemapSymbols(res, deps2, file) {
-  if (!file) {
-    sendJson(res, 400, { error: 'Missing "file" query parameter' });
-    return;
-  }
-  await serveCachedGraph(
-    res,
-    deps2,
-    `symbols:${file}`,
-    () => symbolGraphService({
-      projectRoot: deps2.projectRoot,
-      fileFilter: file,
-      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
-    })
-  );
-}
-
 // src/server/deadcode-handlers.ts
 import * as path10 from "node:path";
 import { runDeadCodeScan } from "@wrongstack/tools/codebase-index";
@@ -6852,7 +7233,84 @@ function buildActionPlan(result) {
   };
 }
 
+// src/server/codemap-handlers.ts
+import { fileGraphService, packageGraphService, symbolGraphService } from "@wrongstack/tools";
+function sendJsonBody(res, status, body, cacheStatus) {
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "X-Codemap-Cache": cacheStatus
+  });
+  res.end(body);
+}
+function sendJson(res, status, data, cacheStatus = "BYPASS") {
+  sendJsonBody(res, status, JSON.stringify(data), cacheStatus);
+}
+async function serveCachedGraph(res, deps2, scope, compute) {
+  try {
+    const version = indexDbVersion(deps2.projectRoot, deps2.indexDir);
+    const key = codemapCacheKey(deps2.projectRoot, deps2.indexDir, scope);
+    const hit = getCachedCodemapBody(key, version);
+    if (hit !== void 0) {
+      sendJsonBody(res, 200, hit, "HIT");
+      return;
+    }
+    const graph = await compute();
+    const body = JSON.stringify(graph);
+    if (version !== "missing") {
+      setCachedCodemapBody(key, version, body);
+    }
+    sendJsonBody(res, 200, body, "MISS");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sendJson(res, 503, { error: "CodeMap index unavailable", detail: msg }, "BYPASS");
+  }
+}
+async function handleCodemapPackages(res, deps2) {
+  await serveCachedGraph(
+    res,
+    deps2,
+    "packages",
+    () => packageGraphService({
+      projectRoot: deps2.projectRoot,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    })
+  );
+}
+async function handleCodemapFiles(res, deps2, pkg) {
+  if (!pkg) {
+    sendJson(res, 400, { error: 'Missing "package" query parameter' });
+    return;
+  }
+  await serveCachedGraph(
+    res,
+    deps2,
+    `files:${pkg}`,
+    () => fileGraphService({
+      projectRoot: deps2.projectRoot,
+      packageFilter: pkg,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    })
+  );
+}
+async function handleCodemapSymbols(res, deps2, file) {
+  if (!file) {
+    sendJson(res, 400, { error: 'Missing "file" query parameter' });
+    return;
+  }
+  await serveCachedGraph(
+    res,
+    deps2,
+    `symbols:${file}`,
+    () => symbolGraphService({
+      projectRoot: deps2.projectRoot,
+      fileFilter: file,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    })
+  );
+}
+
 // src/server/http-server/api-handlers.ts
+import { sanitizeApiError } from "@wrongstack/core/security";
 async function handleApiSessions(res, globalRoot) {
   if (!globalRoot) {
     res.writeHead(500, { "Content-Type": "application/json" });
@@ -6888,7 +7346,7 @@ async function handleApiSessions(res, globalRoot) {
     res.end(JSON.stringify(result));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 async function handleApiSessionAgents(res, globalRoot, sessionId) {
@@ -6923,7 +7381,7 @@ async function handleApiSessionAgents(res, globalRoot, sessionId) {
     }));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 function blocksToText(content) {
@@ -7070,11 +7528,16 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
     );
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 function readJsonBody2(req) {
   return new Promise((resolve15, reject) => {
+    const contentType = (req.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase();
+    if (contentType !== "application/json") {
+      reject(new Error(`Unsupported Content-Type: ${contentType || "(absent)"}`));
+      return;
+    }
     let data = "";
     req.on("data", (chunk) => {
       data += chunk;
@@ -7139,7 +7602,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
     res.end(JSON.stringify({ ok: true, id: sent.id, to, type, delivered: entry.status }));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 async function handleApiSessionMailbox(res, globalRoot, sessionId) {
@@ -7192,7 +7655,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
     res.end(JSON.stringify({ sessionId, leader: leaderAddr, status: entry.status, thread }));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
@@ -7233,7 +7696,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
     res.end(JSON.stringify({ ok: true, id: sent.id, to, delivered: entry.status }));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 async function handleApiFleetBroadcast(res, req, globalRoot) {
@@ -7302,22 +7765,157 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
     res.end(JSON.stringify({ ok: true, delivered, targets: targets.length }));
   } catch (err) {
     res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify({ error: String(err) }));
+    res.end(JSON.stringify({ error: sanitizeApiError(err) }));
   }
 }
 
-// src/server/projects-manifest.ts
+// src/server/memory-diagnostics.ts
 import * as fs8 from "node:fs/promises";
 import * as path11 from "node:path";
+var DEFAULT_TAIL_BYTES = 1024 * 1024;
+var MAX_PROCESSES = 32;
+function finiteNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function stringValue(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function toProcessDiagnostic(record) {
+  const pid = finiteNumber(record, "pid");
+  const ts = stringValue(record, "ts");
+  if (pid === void 0 || ts === void 0) return null;
+  const queueEntries = finiteNumber(record, "hqQueueEntries");
+  const queueBytes = finiteNumber(record, "hqQueueBytes");
+  const queueMaxBytes = finiteNumber(record, "hqQueueMaxBytes");
+  const snapshotInFlight = finiteNumber(record, "hqSnapshotInFlight");
+  const snapshotPending = finiteNumber(record, "hqSnapshotPending");
+  const snapshotTimerScheduled = finiteNumber(record, "hqSnapshotTimerScheduled");
+  const eventInFlight = finiteNumber(record, "hqEventInFlight");
+  const eventPending = finiteNumber(record, "hqEventPending");
+  const eventCoalesced = finiteNumber(record, "hqEventCoalesced");
+  const eventDropped = finiteNumber(record, "hqEventDropped");
+  return {
+    pid,
+    surface: stringValue(record, "surface") ?? "unknown",
+    ...stringValue(record, "sessionId") !== void 0 ? { sessionId: stringValue(record, "sessionId") } : {},
+    ts,
+    memory: {
+      rss: finiteNumber(record, "rss") ?? 0,
+      heapUsed: finiteNumber(record, "heapUsed") ?? 0,
+      heapTotal: finiteNumber(record, "heapTotal") ?? 0,
+      retainedHeapUsed: finiteNumber(record, "retainedHeapUsed"),
+      nativeResidual: finiteNumber(record, "nativeResidual"),
+      external: finiteNumber(record, "external"),
+      arrayBuffers: finiteNumber(record, "arrayBuffers")
+    },
+    signal: stringValue(record, "memorySignal"),
+    heapGrowthBytesPerHour: finiteNumber(record, "heapGrowthBytesPerHour"),
+    rssGrowthBytesPerHour: finiteNumber(record, "rssGrowthBytesPerHour"),
+    workload: {
+      messages: finiteNumber(record, "messages"),
+      messageEstimatedTokens: finiteNumber(record, "messageEstimatedTokens"),
+      historyEntries: finiteNumber(record, "historyEntries"),
+      historyMountedEntries: finiteNumber(record, "historyMountedEntries"),
+      historyCachedGroups: finiteNumber(record, "historyCachedGroups"),
+      appRenders: finiteNumber(record, "appRenders"),
+      metricsDroppedObservations: finiteNumber(record, "metricsDroppedObservations"),
+      kanbanSyncActive: finiteNumber(record, "kanbanSyncActive") === 1,
+      kanbanSyncPendingBoards: finiteNumber(record, "kanbanSyncPendingBoards"),
+      kanbanSyncFullRescanPending: finiteNumber(record, "kanbanSyncFullRescanPending") === 1,
+      kanbanSyncRemoteApplyQueued: finiteNumber(record, "kanbanSyncRemoteApplyQueued") === 1,
+      kanbanSyncPendingRemoteBoards: finiteNumber(record, "kanbanSyncPendingRemoteBoards"),
+      kanbanSyncPublishRuns: finiteNumber(record, "kanbanSyncPublishRuns"),
+      kanbanSyncCoalescedRefreshes: finiteNumber(record, "kanbanSyncCoalescedRefreshes"),
+      kanbanSupervisorSnapshots: finiteNumber(record, "kanbanSupervisorSnapshots"),
+      kanbanSupervisorScheduledBoards: finiteNumber(record, "kanbanSupervisorScheduledBoards"),
+      kanbanSupervisorAgentCooldowns: finiteNumber(record, "kanbanSupervisorAgentCooldowns"),
+      kanbanSupervisorRunningAgents: finiteNumber(record, "kanbanSupervisorRunningAgents")
+    },
+    resources: {
+      active: finiteNumber(record, "activeResources"),
+      types: stringValue(record, "activeResourceTypes")
+    },
+    ...queueEntries !== void 0 && queueBytes !== void 0 && queueMaxBytes !== void 0 ? {
+      hqQueue: {
+        entries: queueEntries,
+        bytes: queueBytes,
+        maxBytes: queueMaxBytes,
+        droppedFrames: finiteNumber(record, "hqQueueDroppedFrames") ?? 0,
+        droppedBytes: finiteNumber(record, "hqQueueDroppedBytes") ?? 0,
+        coalescedFrames: finiteNumber(record, "hqQueueCoalescedFrames") ?? 0,
+        coalescedBytes: finiteNumber(record, "hqQueueCoalescedBytes") ?? 0
+      }
+    } : {},
+    ...snapshotInFlight !== void 0 || snapshotPending !== void 0 || snapshotTimerScheduled !== void 0 ? {
+      hqSnapshot: {
+        inFlight: snapshotInFlight === 1,
+        pending: snapshotPending === 1,
+        timerScheduled: snapshotTimerScheduled === 1,
+        eventInFlight: eventInFlight === 1,
+        pendingEvents: eventPending ?? 0,
+        coalescedEvents: eventCoalesced ?? 0,
+        droppedEvents: eventDropped ?? 0
+      }
+    } : {},
+    profileTopStack: stringValue(record, "memoryProfileTopStack"),
+    profileTopStackBytes: finiteNumber(record, "memoryProfileTopStackBytes")
+  };
+}
+async function readRecentProcessMemoryDiagnostics(globalRoot, tailBytes = DEFAULT_TAIL_BYTES) {
+  if (!globalRoot) return [];
+  const heapLog = path11.join(globalRoot, "logs", "heap.jsonl");
+  let handle;
+  try {
+    handle = await fs8.open(heapLog, "r");
+    const stat3 = await handle.stat();
+    const length = Math.min(stat3.size, Math.max(1, tailBytes));
+    if (length === 0) return [];
+    const start = stat3.size - length;
+    const buffer = Buffer.allocUnsafe(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    let text = buffer.subarray(0, bytesRead).toString("utf8");
+    if (start > 0) {
+      const firstNewline = text.indexOf("\n");
+      if (firstNewline === -1) return [];
+      text = text.slice(firstNewline + 1);
+    }
+    const newestByPid = /* @__PURE__ */ new Map();
+    const lines = text.split(/\r?\n/u);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const line = lines[index]?.trim();
+      if (!line) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) continue;
+        const diagnostic = toProcessDiagnostic(parsed);
+        if (!diagnostic || newestByPid.has(diagnostic.pid)) continue;
+        newestByPid.set(diagnostic.pid, diagnostic);
+        if (newestByPid.size >= MAX_PROCESSES) break;
+      } catch {
+      }
+    }
+    return [...newestByPid.values()].sort((a, b) => b.ts.localeCompare(a.ts));
+  } catch {
+    return [];
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+
+// src/server/projects-manifest.ts
+import * as fs9 from "node:fs/promises";
+import * as path12 from "node:path";
 import { ConfigError } from "@wrongstack/core/types";
 import { projectSlug, withFileLock } from "@wrongstack/core/utils";
 function projectsJsonPath(globalConfigPath) {
-  const base = path11.dirname(globalConfigPath);
-  return path11.join(base, "projects.json");
+  const base = path12.dirname(globalConfigPath);
+  return path12.join(base, "projects.json");
 }
 async function loadManifest(globalConfigPath) {
   try {
-    const raw = await fs8.readFile(projectsJsonPath(globalConfigPath), "utf8");
+    const raw = await fs9.readFile(projectsJsonPath(globalConfigPath), "utf8");
     const parsed = JSON.parse(raw);
     return { projects: parsed.projects ?? [] };
   } catch {
@@ -7326,37 +7924,37 @@ async function loadManifest(globalConfigPath) {
 }
 async function saveManifest(manifest, globalConfigPath) {
   const file = projectsJsonPath(globalConfigPath);
-  await fs8.mkdir(path11.dirname(file), { recursive: true });
-  await fs8.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
+  await fs9.mkdir(path12.dirname(file), { recursive: true });
+  await fs9.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
 }
 function generateProjectSlug(rootPath) {
   return projectSlug(rootPath);
 }
 async function ensureProjectDataDir(slug, globalConfigPath) {
-  const base = path11.dirname(globalConfigPath);
-  const dir = path11.join(base, "projects", slug);
-  await fs8.mkdir(dir, { recursive: true });
+  const base = path12.dirname(globalConfigPath);
+  const dir = path12.join(base, "projects", slug);
+  await fs9.mkdir(dir, { recursive: true });
   return dir;
 }
 async function touchProjectInManifest(options, globalConfigPath) {
-  const root = path11.resolve(options.projectRoot);
+  const root = path12.resolve(options.projectRoot);
   const file = projectsJsonPath(globalConfigPath);
   let entry;
   await withFileLock(file, async () => {
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    entry = manifest.projects.find((candidate) => path11.resolve(candidate.root) === root);
+    entry = manifest.projects.find((candidate) => path12.resolve(candidate.root) === root);
     if (entry) {
       entry.lastSeen = now;
-      if (options.workingDir) entry.lastWorkingDir = path11.resolve(options.workingDir);
+      if (options.workingDir) entry.lastWorkingDir = path12.resolve(options.workingDir);
     } else {
       entry = {
-        name: options.name ?? path11.basename(root),
+        name: options.name ?? path12.basename(root),
         root,
         slug: generateProjectSlug(root),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: options.workingDir ? path11.resolve(options.workingDir) : void 0
+        lastWorkingDir: options.workingDir ? path12.resolve(options.workingDir) : void 0
       };
       manifest.projects.push(entry);
     }
@@ -7598,11 +8196,20 @@ import { timingSafeEqual } from "node:crypto";
 function isLoopbackHostname(hostname) {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
 }
-function isTrustedLoopbackOrigin(origin) {
+function effectivePort(url) {
+  if (url.port) return url.port;
+  return url.protocol === "https:" ? "443" : "80";
+}
+function isTrustedLoopbackOrigin(origin, hostHeader) {
   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" || url.hostname === "::1" || url.hostname === "[::1]";
+    if (!isLoopbackHostname(url.hostname)) return false;
+    const host = (hostHeader ?? "").trim();
+    if (!host) return false;
+    const hostUrl = new URL(`${url.protocol}//${host}`);
+    if (!isLoopbackHostname(hostUrl.hostname)) return false;
+    return effectivePort(url) === effectivePort(hostUrl);
   } catch {
     return false;
   }
@@ -7661,6 +8268,23 @@ function hostHeaderOk(input) {
   }
   return isLoopbackHostname(hostname) || allowedHostname(hostname, input.allowedHostnames);
 }
+function httpRequestOriginOk(input) {
+  const { origin, hostHeader, wsHost, allowedHostnames } = input;
+  if (!hostHeaderOk({ hostHeader, wsHost, allowedHostnames })) return false;
+  if (origin === void 0 || origin === "") return true;
+  if (origin === "null") return false;
+  try {
+    const parsed = new URL(origin);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+    const rawHost = (hostHeader ?? "").trim();
+    if (!rawHost) return false;
+    const requestHost = new URL(`${parsed.protocol}//${rawHost}`).host.toLowerCase();
+    if (parsed.host.toLowerCase() === requestHost) return true;
+    return allowedHostname(parsed.hostname, allowedHostnames);
+  } catch {
+    return false;
+  }
+}
 function verifyClient(input) {
   const {
     origin,
@@ -7681,13 +8305,13 @@ function verifyClient(input) {
     const remoteIp = remoteAddress ?? "";
     const isRemoteLoopback = remoteIp === "127.0.0.1" || remoteIp === "::1";
     if (!isRemoteLoopback && isWildcardBind(wsHost) && !urlTokenOk && !cookieTokenOk) return false;
-    return urlTokenOk || cookieTokenOk || isLoopbackBind(wsHost) && !requireToken;
+    return urlTokenOk || cookieTokenOk;
   }
   try {
     const { hostname: originHostname } = new URL(origin);
     if (isLoopbackHostname(originHostname)) {
       if (requireToken || !isLoopbackBind(wsHost)) return cookieTokenOk;
-      return isTrustedLoopbackOrigin(origin);
+      return cookieTokenOk || isTrustedLoopbackOrigin(origin, hostHeader);
     }
     return cookieTokenOk || Boolean(allowBrowserUrlToken) && urlTokenOk && allowedHostname(originHostname, allowedHostnames);
   } catch {
@@ -7749,7 +8373,7 @@ function cspSourceFromUrl(rawUrl) {
     return void 0;
   }
 }
-var EXTRA_SCRIPT_SOURCES = ["'wasm-unsafe-eval'", "'unsafe-inline'"];
+var EXTRA_SCRIPT_SOURCES = ["'wasm-unsafe-eval'"];
 function buildCspHeader(publicWsUrl, host, port) {
   const connect = /* @__PURE__ */ new Set(["'self'"]);
   const publicWsSource = publicWsUrl ? cspSourceFromUrl(publicWsUrl) : void 0;
@@ -7767,9 +8391,9 @@ function buildCspHeader(publicWsUrl, host, port) {
   return `default-src 'self'; script-src ${scriptSrc}; style-src 'self' 'unsafe-inline'; connect-src ${Array.from(connect).join(" ")}; 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 = path12.resolve(distDir);
-  const resolved = path12.resolve(candidate);
-  return resolved === root || resolved.startsWith(root + path12.sep);
+  const root = path13.resolve(distDir);
+  const resolved = path13.resolve(candidate);
+  return resolved === root || resolved.startsWith(root + path13.sep);
 }
 function decodeSessionId(segment) {
   try {
@@ -7789,8 +8413,18 @@ function strictDecodeParam(segment, res) {
 }
 function createHttpServer(opts) {
   const port = opts.port ?? Number.parseInt(process.env["PORT"] ?? "3456", 10);
-  const distDir = path12.resolve(opts.distDir);
+  const distDir = path13.resolve(opts.distDir);
   const requireAccessToken = Boolean(opts.requireToken) || !isLoopbackBind(opts.host);
+  const trustedHostnames = (() => {
+    const names = [...opts.allowedHostnames ?? []];
+    if (opts.publicWsUrl) {
+      try {
+        names.push(new URL(opts.publicWsUrl).hostname);
+      } catch {
+      }
+    }
+    return names;
+  })();
   let techStackRuntime = null;
   const getTechStackRuntime = async () => {
     if (!opts.projectRoot) throw new Error("Project root not configured");
@@ -7805,6 +8439,16 @@ function createHttpServer(opts) {
   const server = http.createServer(async (req, res) => {
     try {
       const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (!httpRequestOriginOk({
+        origin: req.headers.origin,
+        hostHeader: req.headers.host,
+        wsHost: opts.host,
+        allowedHostnames: trustedHostnames
+      })) {
+        res.writeHead(403, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+        res.end(JSON.stringify({ error: "forbidden: untrusted request origin" }));
+        return;
+      }
       const providedAccessToken = requestToken(req, url);
       const accessTokenOk = Boolean(opts.apiToken) && tokenMatches(providedAccessToken, opts.apiToken ?? "");
       const shouldSetAuthCookie = Boolean(opts.apiToken) && tokenMatches(url.searchParams.get("token") ?? void 0, opts.apiToken ?? "");
@@ -8008,42 +8652,6 @@ function createHttpServer(opts) {
         );
         return;
       }
-      if (url.pathname === "/api/deadcode/scan" && req.method === "POST") {
-        if (requireAccessToken && !accessTokenOk) {
-          res.writeHead(401, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Unauthorized" }));
-          return;
-        }
-        if (!opts.projectRoot) {
-          res.writeHead(503, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Project root not configured" }));
-          return;
-        }
-        const deadCodeDeps = {
-          projectRoot: opts.projectRoot,
-          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
-        };
-        await handleDeadCodeScan(res, deadCodeDeps, req);
-        return;
-      }
-      if (url.pathname === "/api/deadcode/action-plan" && req.method === "POST") {
-        if (requireAccessToken && !accessTokenOk) {
-          res.writeHead(401, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Unauthorized" }));
-          return;
-        }
-        if (!opts.projectRoot) {
-          res.writeHead(503, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Project root not configured" }));
-          return;
-        }
-        const deadCodeDeps = {
-          projectRoot: opts.projectRoot,
-          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
-        };
-        await handleDeadCodeActionPlan(res, deadCodeDeps, req);
-        return;
-      }
       if (url.pathname.startsWith("/api/techstack/")) {
         if (requireAccessToken && !accessTokenOk) {
           res.writeHead(401, { "Content-Type": "application/json" });
@@ -8117,11 +8725,7 @@ function createHttpServer(opts) {
           if (researchMatch && req.method === "POST") {
             const pkg = strictDecodeParam(researchMatch[1], res);
             if (pkg === null) return;
-            await handleTechStackDependencyResearch(
-              res,
-              deps2,
-              pkg
-            );
+            await handleTechStackDependencyResearch(res, deps2, pkg);
             return;
           }
         } catch (error2) {
@@ -8129,7 +8733,7 @@ function createHttpServer(opts) {
           res.end(
             JSON.stringify({
               error: "TechStack store unavailable",
-              detail: error2 instanceof Error ? error2.message : String(error2)
+              detail: sanitizeApiError2(error2)
             })
           );
           return;
@@ -8157,6 +8761,7 @@ function createHttpServer(opts) {
         return;
       }
       if (url.pathname === "/debug/system" && req.method === "GET") {
+        const processes = await readRecentProcessMemoryDiagnostics(opts.globalRoot);
         res.writeHead(200, {
           "Content-Type": "application/json",
           "Cache-Control": "no-store"
@@ -8169,31 +8774,56 @@ function createHttpServer(opts) {
             uptime: process.uptime(),
             cpuUsage: process.cpuUsage(),
             codebaseIndexServer: getIndexState2().server,
+            processes,
             timestamp: Date.now()
           })
         );
         return;
       }
+      if (url.pathname === "/api/deadcode/scan" && req.method === "POST") {
+        if (!opts.projectRoot) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Project root not configured" }));
+          return;
+        }
+        await handleDeadCodeScan(res, {
+          projectRoot: opts.projectRoot,
+          indexDir: opts.indexDir
+        }, req);
+        return;
+      }
+      if (url.pathname === "/api/deadcode/action-plan" && req.method === "POST") {
+        await handleDeadCodeActionPlan(res, {
+          projectRoot: opts.projectRoot ?? "",
+          indexDir: opts.indexDir
+        }, req);
+        return;
+      }
+      if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
+        res.writeHead(404, { "Content-Type": "application/json", "Cache-Control": "no-store" });
+        res.end(JSON.stringify({ error: "Not found" }));
+        return;
+      }
       let filePath;
       if (url.pathname === "/" || url.pathname === "") {
-        filePath = path12.join(distDir, "index.html");
+        filePath = path13.join(distDir, "index.html");
       } else {
-        filePath = path12.join(distDir, url.pathname);
+        filePath = path13.join(distDir, url.pathname);
       }
-      const resolvedPath = path12.resolve(filePath);
+      const resolvedPath = path13.resolve(filePath);
       if (!isInsideDist(resolvedPath, distDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext = path12.extname(resolvedPath);
+      const ext = path13.extname(resolvedPath);
       const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
       res.setHeader("Content-Type", contentType);
       setStaticSecurityHeaders(res);
       if (ext === ".html") {
         if (!shouldSetAuthCookie) res.setHeader("Cache-Control", "no-cache");
         res.setHeader("Content-Security-Policy", buildCspHeader(opts.publicWsUrl, opts.host, port));
-        const html = await fs9.readFile(resolvedPath, "utf8");
+        const html = await fs10.readFile(resolvedPath, "utf8");
         res.writeHead(200);
         res.end(injectWsConfig(html, { publicWsUrl: opts.publicWsUrl }));
         return;
@@ -8204,13 +8834,13 @@ function createHttpServer(opts) {
           url.pathname.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "public, max-age=3600"
         );
       }
-      const fileContent = await fs9.readFile(resolvedPath);
+      const fileContent = await fs10.readFile(resolvedPath);
       res.writeHead(200);
       res.end(fileContent);
     } catch (err) {
       if (err.code === "ENOENT") {
         try {
-          const html = await fs9.readFile(path12.join(distDir, "index.html"), "utf8");
+          const html = await fs10.readFile(path13.join(distDir, "index.html"), "utf8");
           setStaticSecurityHeaders(res);
           res.writeHead(200, {
             "Content-Type": "text/html",
@@ -8240,14 +8870,14 @@ function createHttpServer(opts) {
 
 // src/server/instance-registry.ts
 import * as os from "node:os";
-import * as path13 from "node:path";
-import * as fs10 from "node:fs/promises";
+import * as path14 from "node:path";
+import * as fs11 from "node:fs/promises";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core/utils";
 function defaultBaseDir() {
-  return path13.join(os.homedir(), ".wrongstack");
+  return path14.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path13.join(baseDir, "webui-instances.json");
+  return path14.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -8260,7 +8890,7 @@ function isPidAlive(pid) {
 }
 async function load(file) {
   try {
-    const raw = await fs10.readFile(file, "utf8");
+    const raw = await fs11.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.version === 1 && Array.isArray(parsed.instances)) {
       return parsed;
@@ -8472,6 +9102,11 @@ async function handleIntrospectionRoute(ctx, ws, message) {
           cwd: ctx.getProjectRoot(),
           sessionId: ctx.getSessionId(),
           tools: { count: tools.length, names: tools.map((tool) => tool.name) },
+          maxTools: actx.provider.maxToolsCount ?? 0,
+          droppedTools: (() => {
+            const mt = actx.provider.maxToolsCount ?? 0;
+            return mt > 0 ? Math.max(0, tools.length - mt) : 0;
+          })(),
           features: {
             memory: !!config.features?.memory,
             skills: !!config.features?.skills,
@@ -8573,40 +9208,17 @@ async function handleIntrospectionRoute(ctx, ws, message) {
 }
 
 // src/server/kanban-dispatch.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   areDependenciesMet,
   getServerKanbanStore
 } from "@wrongstack/kanban";
 import { recordKanbanVerificationEvidence } from "@wrongstack/tools";
-function parseResolvedDispatchRoute(summary) {
-  const tags = summary.match(/Spawned subagent\s+\S+\s+\((.*?)\)\s+for task/i)?.[1];
-  if (!tags) return {};
-  const parts = tags.split(/\s+\/\s+/).map((part) => part.trim());
-  const positional = parts.filter((part) => !part.includes("=") && !part.startsWith('"'));
-  const fallbackProfile = parts.find((part) => part.startsWith("profile="))?.slice(8);
-  const fallback = parts.find((part) => part.startsWith("fallback="))?.slice(9);
-  return {
-    ...positional[0] ? { provider: positional[0] } : {},
-    ...positional[1] ? { model: positional[1] } : {},
-    ...fallbackProfile ? { fallbackProfile } : {},
-    ...fallback ? { fallbackModels: fallback.split(",").filter(Boolean) } : {}
-  };
-}
 function reply(ws, type, success, value) {
   send(ws, {
     type,
     payload: success ? { success: true, data: value } : { success: false, error: String(value) }
   });
 }
-function activityContext(ctx, note, expectedLeaseId) {
-  const sessionId = ctx.context?.session?.id;
-  return {
-    ...sessionId ? { sessionId } : {},
-    ...note?.trim() ? { note: note.trim() } : {},
-    ...expectedLeaseId ? { expectedLeaseId } : {}
-  };
-}
 async function handleKanbanTaskDispatch(ws, payload, ctx) {
   const boardId = payload?.boardId;
   const taskId = payload?.taskId;
@@ -8645,45 +9257,39 @@ async function handleKanbanTaskDispatch(ws, payload, ctx) {
   }
   const modelRouting = payload?.modelRouting ?? task.assignment?.modelRouting ?? (payload?.provider || payload?.model || task.assignment?.provider || task.assignment?.model ? "fixed" : "session");
   const useSessionModel = modelRouting === "session";
-  const leaseId = randomUUID3();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
   const leaseTtlMs = 30 * 60 * 1e3;
-  const leaseExpiresAt = new Date(Date.now() + leaseTtlMs).toISOString();
-  const assignment = {
-    agentId: payload?.agentId ?? task.assignment?.agentId ?? task.assignedAgent,
-    name: payload?.name ?? task.assignment?.name ?? task.assignedAgent,
-    role: payload?.role ?? task.assignment?.role,
-    modelRouting,
-    provider: useSessionModel ? ctx.context?.provider.id : payload?.provider ?? task.assignment?.provider,
-    model: useSessionModel ? ctx.context?.model : payload?.model ?? task.assignment?.model,
-    fallbackProfile: modelRouting === "fallback_profile" ? payload?.fallbackProfile ?? task.assignment?.fallbackProfile : void 0,
-    fallbackModels: payload?.fallbackModels ?? task.assignment?.fallbackModels,
-    skills: payload?.skills ?? task.assignment?.skills,
-    tools: payload?.tools ?? task.assignment?.tools,
-    allowedCapabilities: payload?.allowedCapabilities ?? task.assignment?.allowedCapabilities,
-    maxAttempts: payload?.maxAttempts ?? task.assignment?.maxAttempts,
-    costCeilingUsd: payload?.costCeilingUsd ?? task.assignment?.costCeilingUsd ?? task.costCeilingUsd,
-    retryPolicy: payload?.retryPolicy ?? task.assignment?.retryPolicy ?? task.retryPolicy,
-    attempt: (task.assignment?.attempt ?? 0) + 1,
-    status: "queued",
-    dispatchedAt: now,
-    leaseId,
-    claimedAt: now,
-    heartbeatAt: now,
-    leaseExpiresAt
-  };
-  const assignedBoard = await store.assignTask(
+  const reserved = await store.reserveKanbanDispatch({
     boardId,
-    task.id,
-    assignment,
-    activityContext(ctx, payload?.activityNote)
-  );
-  if (!assignedBoard) {
-    reply(ws, "kanban.task.dispatch", false, `Failed to assign task "${task.title}". The task may have been removed or the board does not allow external assignment.`);
+    taskId: task.id,
+    routing: {
+      agentId: payload?.agentId ?? task.assignment?.agentId ?? task.assignedAgent,
+      name: payload?.name ?? task.assignment?.name ?? task.assignedAgent,
+      role: payload?.role ?? task.assignment?.role,
+      modelRouting,
+      provider: useSessionModel ? ctx.context?.provider.id : payload?.provider ?? task.assignment?.provider,
+      model: useSessionModel ? ctx.context?.model : payload?.model ?? task.assignment?.model,
+      fallbackProfile: modelRouting === "fallback_profile" ? payload?.fallbackProfile ?? task.assignment?.fallbackProfile : void 0,
+      fallbackModels: payload?.fallbackModels ?? task.assignment?.fallbackModels,
+      skills: payload?.skills ?? task.assignment?.skills,
+      tools: payload?.tools ?? task.assignment?.tools,
+      allowedCapabilities: payload?.allowedCapabilities ?? task.assignment?.allowedCapabilities
+    },
+    budget: {
+      maxAttempts: payload?.maxAttempts ?? task.assignment?.maxAttempts,
+      costCeilingUsd: payload?.costCeilingUsd ?? task.assignment?.costCeilingUsd ?? task.costCeilingUsd,
+      retryPolicy: payload?.retryPolicy ?? task.assignment?.retryPolicy ?? task.retryPolicy
+    },
+    leaseTtlMs,
+    heartbeatIntervalMs: Math.floor(leaseTtlMs / 2)
+  });
+  if (!reserved) {
+    reply(ws, "kanban.task.dispatch", false, `Failed to reserve task "${task.title}". The task may have been claimed by another agent or removed.`);
     return;
   }
+  const dispatchLeaseId = reserved.lease.leaseId;
   try {
-    const summary = await ctx.dispatchTask(buildKanbanAgentPrompt(board, task, assignment, leaseId), {
+    const assignment = reserved.task.assignment ?? { status: "queued" };
+    const summary = await ctx.dispatchTask(buildKanbanAgentPrompt(board, task, assignment, dispatchLeaseId), {
       ...assignment.provider ? { provider: assignment.provider } : {},
       ...assignment.model ? { model: assignment.model } : {},
       ...assignment.fallbackModels ? { fallbackModels: assignment.fallbackModels } : {},
@@ -8692,69 +9298,40 @@ async function handleKanbanTaskDispatch(ws, payload, ctx) {
       ...assignment.tools ? { tools: assignment.tools } : {},
       ...assignment.name ? { name: assignment.name } : {},
       ...assignment.allowedCapabilities ? { allowedCapabilities: assignment.allowedCapabilities } : {},
-      context: { kanban: { boardId, taskId: task.id, projectRoot: ctx.projectRoot, leaseId } },
+      context: { kanban: { boardId, taskId: task.id, projectRoot: ctx.projectRoot, leaseId: dispatchLeaseId } },
       onDone: async (result) => {
-        const terminalWrite = await store.updateTaskAssignment(
-          boardId,
-          task.id,
-          {
-            ...assignment,
-            status: result.status,
-            ...result.result !== void 0 ? { lastResult: result.result } : {},
-            ...result.error !== void 0 ? { error: result.error } : {}
-          },
-          activityContext(ctx, void 0, leaseId)
-        );
-        if (result.status === "completed" && terminalWrite) {
-          try {
-            const finalized = await store.finalizeTaskCompletion(boardId, task.id, {
-              eventContext: activityContext(ctx, void 0, leaseId)
-            });
-            if (finalized?.gate.report && ctx.context) {
-              recordKanbanVerificationEvidence(ctx.context, finalized.gate.report);
-            }
-          } catch (error2) {
-            console.warn(
-              `[kanban-dispatch] completion gate failed for task ${task.id}: ${error2 instanceof Error ? error2.message : String(error2)}`
-            );
-          }
-          if (terminalWrite.lifecycle?.mode === "managed") {
-            const managedTask = terminalWrite.tasks.find(
-              (candidate) => candidate.id === task.id
-            );
-            if (managedTask && managedTask.lifecycle?.currentStage === "running") {
-              const actor = ctx.context?.agentId ?? "kanban-agent";
-              const comment = typeof result.result === "string" && result.result.trim().length > 0 ? result.result.trim().slice(0, 1e3) : "Work completed.";
-              try {
-                await store.transitionTask(boardId, task.id, {
-                  to: "review",
-                  actor,
-                  comment,
-                  attachment: {
-                    url: `kanban://task/${task.id}/result`,
-                    title: "Worker completion result",
-                    type: "file"
-                  }
-                });
-              } catch (transitionError) {
-                console.warn(
-                  `[kanban-dispatch] auto-transition to review failed for task ${task.id}: ${transitionError instanceof Error ? transitionError.message : String(transitionError)}`
-                );
-              }
-            }
+        if (result.status === "completed") {
+          const completed = await store.completeKanbanDispatch({
+            boardId,
+            taskId: task.id,
+            leaseId: dispatchLeaseId,
+            actor: ctx.context?.agentId ?? "kanban-agent",
+            result: result.result,
+            evidence: result.result ? { url: `kanban://task/${task.id}/result`, title: "Worker completion result", type: "file" } : void 0
+          });
+          if (completed?.task.verificationReport && ctx.context) {
+            recordKanbanVerificationEvidence(ctx.context, completed.task.verificationReport);
           }
+        } else {
+          await store.failKanbanDispatch({
+            boardId,
+            taskId: task.id,
+            leaseId: dispatchLeaseId,
+            actor: ctx.context?.agentId ?? "kanban-agent",
+            error: result.error ?? "Task failed."
+          });
         }
         const reconciled = await store.reconcileBoard(boardId);
-        const completed = reconciled?.board ?? await store.getBoard(boardId);
-        const completedTask = completed?.tasks.find((candidate) => candidate.id === task.id) ?? task;
+        const completedBoard = reconciled?.board ?? await store.getBoard(boardId);
+        const completedTask = completedBoard?.tasks.find((candidate) => candidate.id === task.id) ?? task;
         ctx.broadcast?.({
           type: "kanban.task.update",
           payload: { success: true, data: { boardId: board.id, task: completedTask } }
         });
-        if (completed) {
+        if (completedBoard) {
           ctx.broadcast?.({
             type: "kanban.get",
-            payload: { success: true, data: { board: completed } }
+            payload: { success: true, data: { board: completedBoard } }
           });
         }
         ctx.broadcast?.({
@@ -8765,55 +9342,32 @@ async function handleKanbanTaskDispatch(ws, payload, ctx) {
     });
     const subagentId = summary.match(/Spawned subagent\s+([^\s]+)/)?.[1];
     const runTaskId = summary.match(/\bfor task\s+([^\s.]+)/i)?.[1];
-    const resolvedRoute = parseResolvedDispatchRoute(summary);
-    const updated = await store.updateTaskAssignment(
+    const started = await store.startKanbanDispatch({
       boardId,
-      task.id,
-      {
-        ...assignment,
-        ...resolvedRoute,
-        status: "running",
-        ...subagentId ? { subagentId } : {},
-        ...runTaskId ? { runTaskId } : {},
-        lastResult: summary
-      },
-      activityContext(ctx, void 0, leaseId)
-    );
-    let transitionBoard = updated;
-    if (updated?.lifecycle?.mode === "managed") {
-      const managedTask = updated.tasks.find((candidate) => candidate.id === task.id);
-      if (managedTask && managedTask.lifecycle?.currentStage === "todo") {
-        try {
-          const tr = await store.transitionTask(boardId, task.id, {
-            to: "running",
-            actor: ctx.context?.agentId ?? "kanban-agent",
-            comment: "Work started."
-          });
-          if (tr) transitionBoard = tr.board;
-        } catch (transitionErr) {
-          console.warn(
-            `[kanban-dispatch] auto-transition to Running failed for task ${task.id}: ${transitionErr instanceof Error ? transitionErr.message : String(transitionErr)}`
-          );
-        }
-      }
-    }
-    const runningTask = transitionBoard?.tasks.find((candidate) => candidate.id === task.id) ?? task;
+      taskId: task.id,
+      leaseId: dispatchLeaseId,
+      actor: ctx.context?.agentId ?? "kanban-agent",
+      ...subagentId ? { subagentId } : {},
+      ...runTaskId ? { runTaskId } : {}
+    });
+    const runningTask = started?.task ?? (started?.board.tasks.find((candidate) => candidate.id === task.id) ?? task);
     ctx.broadcast?.({
       type: "kanban.task.update",
       payload: { success: true, data: { boardId: board.id, task: runningTask } }
     });
-    if (updated) {
-      ctx.broadcast?.({ type: "kanban.get", payload: { success: true, data: { board: updated } } });
+    if (started?.board) {
+      ctx.broadcast?.({ type: "kanban.get", payload: { success: true, data: { board: started.board } } });
     }
     reply(ws, "kanban.task.dispatch", true, { boardId: board.id, task: runningTask, summary });
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
-    await store.updateTaskAssignment(
+    await store.failKanbanDispatch({
       boardId,
-      task.id,
-      { ...assignment, status: "failed", error: message },
-      activityContext(ctx, void 0, leaseId)
-    );
+      taskId: task.id,
+      leaseId: dispatchLeaseId,
+      actor: ctx.context?.agentId ?? "kanban-agent",
+      error: message
+    });
     reply(ws, "kanban.task.dispatch", false, message);
   }
 }
@@ -8967,7 +9521,7 @@ function fail(ws, type, message) {
 function has(payload, key) {
   return payload !== void 0 && Object.hasOwn(payload, key);
 }
-function activityContext2(ctx, actor, note) {
+function activityContext(ctx, actor, note) {
   const sessionId = ctx.context?.session?.id;
   return {
     ...sessionId ? { sessionId } : {},
@@ -9204,7 +9758,7 @@ async function handleTaskActivityAdd(ws, type, payload, ctx) {
       outcome,
       ...typeof payload?.details === "string" && payload.details.trim() ? { details: payload.details.trim() } : {}
     },
-    activityContext2(
+    activityContext(
       ctx,
       payload?.actor ?? ctx.context?.agentId ?? "webui"
     )
@@ -9518,7 +10072,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             ...payload?.labels ? { labels: payload.labels } : {},
             ...has(payload, "boundary") ? { boundary: payload?.boundary } : {}
           },
-          activityContext2(ctx, "webui", payload?.activityNote)
+          activityContext(ctx, "webui", payload?.activityNote)
         );
         result ? ok(ws, type, result.task) : fail(ws, type, `Board not found: ${boardId}`);
         return true;
@@ -9602,7 +10156,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
               boundary: payload?.boundary ?? null
             } : {}
           },
-          activityContext2(ctx, "webui", payload?.activityNote)
+          activityContext(ctx, "webui", payload?.activityNote)
         );
         if (!board) {
           fail(ws, type, "Board or task not found");
@@ -9653,7 +10207,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
           taskId,
           columnId,
           payload?.order,
-          activityContext2(ctx, "webui", payload?.activityNote)
+          activityContext(ctx, "webui", payload?.activityNote)
         );
         if (!board) {
           fail(ws, type, "Move failed");
@@ -9770,7 +10324,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             ...payload?.unit ? { unit: payload.unit } : {},
             ...payload?.notes ? { notes: payload.notes } : {}
           },
-          activityContext2(
+          activityContext(
             ctx,
             "webui",
             payload?.activityNote ?? `Goal metric added: ${name2}.`
@@ -9800,7 +10354,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             ...payload?.unit ? { unit: payload.unit } : {},
             ...payload?.notes ? { notes: payload.notes } : {}
           },
-          activityContext2(
+          activityContext(
             ctx,
             "webui",
             payload?.activityNote ?? "Goal metric updated in WebUI."
@@ -9837,7 +10391,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             ...payload?.costCeilingUsd !== void 0 ? { costCeilingUsd: Number(payload.costCeilingUsd) } : {},
             ...payload?.retryPolicy ? { retryPolicy: payload.retryPolicy } : {}
           },
-          activityContext2(ctx, void 0, payload?.activityNote)
+          activityContext(ctx, void 0, payload?.activityNote)
         );
         board ? ok(ws, type, findTask2(board.tasks, taskId)) : fail(ws, type, "Board or task not found");
         return true;
@@ -9859,7 +10413,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             type: payload?.checkType ?? "manual",
             status: payload?.status ?? "pending"
           },
-          activityContext2(
+          activityContext(
             ctx,
             "webui",
             payload?.activityNote ?? `Acceptance check added: ${description}.`
@@ -9884,7 +10438,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
           {
             ...has(payload, "status") ? { status: payload?.status } : {}
           },
-          activityContext2(
+          activityContext(
             ctx,
             "webui",
             payload?.activityNote ?? `Acceptance check updated${payload?.status ? ` to ${String(payload.status)}` : ""}.`
@@ -9911,7 +10465,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
             author,
             content
           },
-          activityContext2(ctx, author)
+          activityContext(ctx, author)
         );
         board ? ok(ws, type, board) : fail(ws, type, "Board or task not found");
         return true;
@@ -10058,14 +10612,14 @@ function registerShutdownHandlers(res) {
 }
 
 // src/server/config-doctor.ts
-import * as fs11 from "node:fs/promises";
+import * as fs12 from "node:fs/promises";
 import {
   repairConfigDefaults
 } from "@wrongstack/core/storage";
 import { atomicWrite as atomicWrite5 } from "@wrongstack/core/utils";
 import { decryptConfigSecrets } from "@wrongstack/core/security";
 async function readConfig(file, vault) {
-  const raw = await fs11.readFile(file, "utf8");
+  const raw = await fs12.readFile(file, "utf8");
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("Active profile config must contain a JSON object.");
@@ -10129,6 +10683,7 @@ async function handleConfigDoctor(ws, apply, deps2) {
 
 // src/server/mailbox-handlers.ts
 import {
+  actionToAckInput,
   getSharedProjectMailbox,
   isMailboxMessageVisibleTo,
   MAILBOX_TYPE_PROPERTIES,
@@ -10145,6 +10700,43 @@ function getMailboxForDeps(deps2) {
   const dir = resolveProjectDir(projectRoot, globalRoot);
   return getSharedProjectMailbox(dir, deps2.events);
 }
+async function handleMailboxAction(ws, deps2, payload) {
+  const mb = getMailboxForDeps(deps2);
+  if (!mb) {
+    send(ws, {
+      type: "mailbox.action_result",
+      payload: {
+        requestId: payload.requestId,
+        success: false,
+        error: "No project root available"
+      }
+    });
+    return;
+  }
+  try {
+    const message = payload.action === "soft-delete" ? await mb.softDelete(payload.mailId, payload.readerId) : await mb.ack(actionToAckInput(payload.action, payload));
+    send(ws, {
+      type: "mailbox.action_result",
+      payload: {
+        requestId: payload.requestId,
+        success: message !== null,
+        action: payload.action,
+        mailId: payload.mailId
+      }
+    });
+  } catch (err) {
+    send(ws, {
+      type: "mailbox.action_result",
+      payload: {
+        requestId: payload.requestId,
+        success: false,
+        action: payload.action,
+        mailId: payload.mailId,
+        error: errMessage(err)
+      }
+    });
+  }
+}
 async function handleMailboxSend(ws, deps2, payload) {
   const mb = getMailboxForDeps(deps2);
   if (!mb) {
@@ -10160,7 +10752,7 @@ async function handleMailboxSend(ws, deps2, payload) {
   }
   try {
     const message = await mb.send({
-      from: "webui",
+      from: payload.from ?? "webui",
       to: payload.to,
       type: payload.type,
       audience: payload.audience,
@@ -10175,6 +10767,7 @@ async function handleMailboxSend(ws, deps2, payload) {
         requestId: payload.requestId,
         success: true,
         messageId: message.id,
+        from: message.from,
         to: message.to,
         audience: message.audience ?? "all"
       }
@@ -10219,6 +10812,7 @@ async function handleMailboxMessages(ws, deps2, payload) {
     send(ws, {
       type: "mailbox.messages",
       payload: {
+        ...payload?.unreadOnly === true ? { unreadOnly: true } : {},
         messages: visibleMessages.map((m) => {
           const readByMe = payload?.agentId !== void 0 ? payload.agentId in m.readBy : false;
           const completedByMe = payload?.agentId !== void 0 ? m.completedBy === payload.agentId : false;
@@ -10334,6 +10928,14 @@ function createMailboxRouteHandlers(ctx) {
     ...ctx.events ? { events: ctx.events } : {}
   };
   return {
+    action: (ws, msg) => {
+      const parsed = validateMailboxActionPayload(msg.payload);
+      if (!parsed.ok) {
+        sendResult2(ws, false, parsed.message);
+        return;
+      }
+      return handleMailboxAction(ws, deps2, parsed.value);
+    },
     send: (ws, msg) => {
       const parsed = validateMailboxSendPayload(msg.payload);
       if (!parsed.ok) {
@@ -10384,6 +10986,9 @@ function createMailboxRouteHandlers(ctx) {
 }
 async function handleMailboxRoute(ws, msg, handlers) {
   switch (msg.type) {
+    case "mailbox.action":
+      await handlers.action(ws, msg);
+      return true;
     case "mailbox.send":
       await handlers.send(ws, msg);
       return true;
@@ -10409,12 +11014,14 @@ async function handleMailboxRoute(ws, msg, handlers) {
 
 // src/server/mcp-handlers.ts
 import { allServers } from "@wrongstack/core/infrastructure";
+import { DefaultSecretScrubber, isSecretField } from "@wrongstack/core/security";
 import {
   addMcp,
   disableMcp,
   discoverMcp,
   enableMcp,
   listMcp,
+  MCP_ENV_MASK,
   removeMcp,
   restartMcp,
   updateMcp
@@ -10434,6 +11041,15 @@ function mapStatus(raw) {
       return "stopped";
   }
 }
+var envScrubber = new DefaultSecretScrubber();
+function maskServerEnv(env) {
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    const secret = isSecretField(key) || typeof value === "string" && envScrubber.scrub(value) !== value;
+    out[key] = secret ? MCP_ENV_MASK : value;
+  }
+  return out;
+}
 function toView(info, health) {
   const view = {
     name: info.name,
@@ -10448,7 +11064,7 @@ function toView(info, health) {
   if (info.lazy !== void 0) view.lazy = info.lazy;
   if (info.command !== void 0) view.command = info.command;
   if (info.args !== void 0) view.args = info.args;
-  if (info.env !== void 0) view.env = info.env;
+  if (info.env !== void 0) view.env = maskServerEnv(info.env);
   if (info.url !== void 0) view.url = info.url;
   if (health !== void 0) view.health = health;
   return view;
@@ -10487,7 +11103,15 @@ async function handleMcpList(ws, _msg, globalConfigPath, mcpRegistry) {
 async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
   const d = deps(ws, globalConfigPath, mcpRegistry);
   if (!d) return;
-  const result = await addMcp(msg.payload, d);
+  const validated = validateMcpServerPayload(msg.payload, "mcp.add");
+  if (!validated.ok) {
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: false, message: validated.message }
+    });
+    return;
+  }
+  const result = await addMcp(validated.value, d);
   if (result.ok && result.server) {
     send(ws, { type: "mcp.server.added", payload: { server: toView(result.server) } });
     if (result.registryError) {
@@ -10507,7 +11131,15 @@ async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
 async function handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry) {
   const d = deps(ws, globalConfigPath, mcpRegistry);
   if (!d) return;
-  const result = await updateMcp(msg.payload, d);
+  const validated = validateMcpServerPayload(msg.payload, "mcp.update");
+  if (!validated.ok) {
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: false, message: validated.message }
+    });
+    return;
+  }
+  const result = await updateMcp(validated.value, d);
   if (result.ok && result.server) {
     send(ws, { type: "mcp.server.updated", payload: { server: toView(result.server) } });
   }
@@ -11024,7 +11656,7 @@ async function handleSageDelete(ws, msg, memoryStore) {
   }
   try {
     await Sage.deleteSage(id, reason, {
-      force: force ?? true,
+      force: force === true,
       neverInject: neverInject === true
     });
     send(ws, {
@@ -11607,11 +12239,11 @@ function createModelOperations(context) {
 }
 
 // src/server/port-utils.ts
-import * as net from "node:net";
+import * as net2 from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
 function isPortFree(host, port) {
   return new Promise((resolve15) => {
-    const srv = net.createServer();
+    const srv = net2.createServer();
     srv.once("error", () => resolve15(false));
     srv.once("listening", () => {
       srv.close(() => resolve15(true));
@@ -11839,6 +12471,7 @@ function seedContextMeta(config, context) {
   meta["enhanceLanguage"] = autonomyCfg["enhanceLanguage"] ?? "original";
   meta["nextPrediction"] = config.nextPrediction ?? false;
   meta["fallbackModels"] = config.fallbackModels ?? [];
+  meta["fallbackBridge"] = config.fallbackBridge ?? "";
   meta["fallbackProfiles"] = config.fallbackProfiles ?? {};
   meta["favoriteModels"] = config.favoriteModels ?? [];
   meta["favoriteModelsOnly"] = config.favoriteModelsOnly === true;
@@ -11875,7 +12508,7 @@ function seedContextMeta(config, context) {
   meta["refinerModel"] = autonomyCfg["refinerModel"] ?? "";
   meta["refinerFallbackProfile"] = autonomyCfg["refinerFallbackProfile"] ?? "";
   meta["thinkingWord"] = autonomyCfg["thinkingWord"] ?? "thinking";
-  meta["statuslineMode"] = autonomyCfg["statuslineMode"] ?? "detailed";
+  meta["statuslineMode"] = autonomyCfg["statuslineMode"] ?? "minimum";
   meta["animationStyle"] = autonomyCfg["animationStyle"] ?? "rainbow";
   meta["showModelReasoning"] = autonomyCfg["showModelReasoning"] !== false;
   meta["breakerEnabled"] = config.circuitBreaker?.enabled === true;
@@ -11921,7 +12554,10 @@ function seedContextMeta(config, context) {
     try {
       const mgr = new FallbackProfileManager(config);
       const named = autoReviewExt?.["fallbackProfile"];
-      resolvedChain = typeof named === "string" && named.length > 0 ? mgr.resolve(named) : mgr.resolveEffective({ fallbackAuto: true });
+      resolvedChain = typeof named === "string" && named.length > 0 ? mgr.resolveEffective({ fallbackProfile: named, fallbackAuto: false }) : mgr.resolveEffective({
+        fallbackModels: config.fallbackModels,
+        fallbackAuto: config.fallbackAuto !== false
+      });
     } catch {
       resolvedChain = [];
     }
@@ -11930,8 +12566,8 @@ function seedContextMeta(config, context) {
 }
 
 // src/server/pref-helpers.ts
-import * as fs12 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as fs13 from "node:fs/promises";
+import * as path15 from "node:path";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets } from "@wrongstack/core/security";
 import { atomicWrite as atomicWrite6, backupConfigFile, FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS2 } from "@wrongstack/core/utils";
 var PREF_KEYS = [
@@ -12027,11 +12663,11 @@ function prefSnapshot(contextMeta) {
   return snapshot;
 }
 async function writeGlobalConfigFile(filePath, vault, mutate, logger, errorLabel) {
-  const globalRoot = path14.dirname(filePath);
+  const globalRoot = path15.dirname(filePath);
   await backupConfigFile(filePath, { globalRoot });
   let raw;
   try {
-    raw = await fs12.readFile(filePath, "utf8");
+    raw = await fs13.readFile(filePath, "utf8");
   } catch {
     raw = "{}";
   }
@@ -12065,7 +12701,28 @@ async function updateGlobalConfig(deps2, holder, mutate, errorLabel) {
     );
   }
 }
-var DISPLAY_ONLY_KEYS = /* @__PURE__ */ new Set(["groupToolCalls", "showThinkingLogs", "autoReviewFallbackModels"]);
+var DISPLAY_ONLY_KEYS = /* @__PURE__ */ new Set([
+  "groupToolCalls",
+  "showThinkingLogs",
+  "autoReviewFallbackModels",
+  // v11 Display parity: agent-swarm panel + inverse fsAccess flag.
+  // The TUI settings picker mirrors these so the browser can keep the
+  // panel state in sync without round-tripping through config.
+  "showAgentSwarmPanel",
+  "allowOutsideProjectRoot",
+  // v13 Display parity: codebase-index read-tool, SAGE memory-inject
+  // surfacing, pre-refine countdown, inject threshold, multi-diff
+  // footer threshold, refine-panel enhance countdown. All six are
+  // pure panel-toggles; the underlying engine knobs (when applicable)
+  // live in the TUI keyboard shortcut or the agent runtime, not in
+  // config.
+  "readSymbols",
+  "showSageMemoryInject",
+  "preRefineSeconds",
+  "sageMemoryInjectThreshold",
+  "multiDiffSummaryThreshold",
+  "enhanceCountdownMs"
+]);
 async function persistPrefsToConfig(deps2, holder, payload) {
   payload = { ...payload };
   for (const k of DISPLAY_ONLY_KEYS) delete payload[k];
@@ -12080,7 +12737,7 @@ async function persistPrefsToConfig(deps2, holder, payload) {
         autonomyCfg[key] = val;
         autonomyTouched = true;
       };
-      if (typeof payload["autonomy"] === "string" && ["off", "suggest", "auto"].includes(payload["autonomy"])) {
+      if (typeof payload["autonomy"] === "string" && ["off", "suggest", "auto", "eternal", "eternal-parallel"].includes(payload["autonomy"])) {
         setAutonomy("defaultMode", payload["autonomy"]);
       }
       if (typeof payload["autonomyDelayMs"] === "number")
@@ -12376,14 +13033,14 @@ import { createCompatibilityTrustBoundary } from "@wrongstack/core/security";
 import { getProcessRegistry as getProcessRegistry2 } from "@wrongstack/tools";
 
 // src/server/privileged-actions.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   isTrustDecisionAllowed
 } from "@wrongstack/core/security";
 async function authorizeWebUIAction(boundary, action, logger) {
   const request = {
     version: 1,
-    requestId: randomUUID4(),
+    requestId: randomUUID3(),
     actor: {
       kind: "remote-client",
       ...action.sessionId ? { sessionId: action.sessionId } : {}
@@ -12506,8 +13163,8 @@ async function handleProcessRoute(ws, msg, handlers) {
 }
 
 // src/server/project-handlers.ts
-import * as fs13 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as fs14 from "node:fs/promises";
+import * as path16 from "node:path";
 import { DefaultSessionStore } from "@wrongstack/core/storage";
 import { resolveWstackPaths as resolveWstackPaths4 } from "@wrongstack/core/utils";
 function createProjectHandlers(ctx) {
@@ -12559,10 +13216,10 @@ function createProjectHandlers(ctx) {
         });
         return;
       }
-      const resolved = path15.resolve(parsed.value.root);
-      const name2 = parsed.value.name?.trim() || path15.basename(resolved);
+      const resolved = path16.resolve(parsed.value.root);
+      const name2 = parsed.value.name?.trim() || path16.basename(resolved);
       try {
-        const stat3 = await fs13.stat(resolved).catch(() => null);
+        const stat3 = await fs14.stat(resolved).catch(() => null);
         if (!stat3?.isDirectory()) {
           sendTo(ws, {
             type: "projects.added",
@@ -12571,7 +13228,7 @@ function createProjectHandlers(ctx) {
           return;
         }
         const before = await loadManifest(ctx.globalConfigPath);
-        const already = before.projects.some((project) => path15.resolve(project.root) === resolved);
+        const already = before.projects.some((project) => path16.resolve(project.root) === resolved);
         const entry = await touchProjectInManifest(
           { projectRoot: resolved, workingDir: resolved, name: name2 },
           ctx.globalConfigPath
@@ -12601,8 +13258,8 @@ function createProjectHandlers(ctx) {
         });
         return;
       }
-      const resolved = path15.resolve(parsed.value.root);
-      const name2 = parsed.value.name?.trim() || path15.basename(resolved);
+      const resolved = path16.resolve(parsed.value.root);
+      const name2 = parsed.value.name?.trim() || path16.basename(resolved);
       if (!ctx.allowProjectMutations) {
         sendTo(ws, {
           type: "projects.selected",
@@ -12615,7 +13272,7 @@ function createProjectHandlers(ctx) {
         return;
       }
       try {
-        const stat3 = await fs13.stat(resolved).catch(() => null);
+        const stat3 = await fs14.stat(resolved).catch(() => null);
         if (!stat3?.isDirectory()) {
           sendTo(ws, {
             type: "projects.selected",
@@ -12645,7 +13302,7 @@ function createProjectHandlers(ctx) {
         const previousIdentityTarget = {
           projectSlug: previousPaths.projectSlug,
           projectRoot: previousProjectRoot,
-          projectName: path15.basename(previousProjectRoot),
+          projectName: path16.basename(previousProjectRoot),
           workingDir: ctx.context.workingDir
         };
         const previousUsage = ctx.tokenCounter.total();
@@ -12742,7 +13399,7 @@ function createProjectHandlers(ctx) {
 
 // src/server/provider-handlers.ts
 import { resolveProviderModelList } from "@wrongstack/core/models";
-import { DefaultSecretScrubber } from "@wrongstack/core/security";
+import { DefaultSecretScrubber as DefaultSecretScrubber2 } from "@wrongstack/core/security";
 import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
 import {
   beginOAuthLogin
@@ -12808,14 +13465,14 @@ async function searchCatalogModels(registry, rawQuery, limit = 8) {
 }
 
 // src/server/provider-config-io.ts
-import * as fs14 from "node:fs/promises";
+import * as fs15 from "node:fs/promises";
 import { ConfigError as ConfigError2 } from "@wrongstack/core/types";
 import { atomicWrite as atomicWrite7 } from "@wrongstack/core/utils";
 import { decryptConfigSecrets as decryptConfigSecrets3, encryptConfigSecrets as encryptConfigSecrets2 } from "@wrongstack/core/security";
 async function loadSavedProviders(configPath, vault) {
   let raw;
   try {
-    raw = await fs14.readFile(configPath, "utf8");
+    raw = await fs15.readFile(configPath, "utf8");
   } catch {
     return {};
   }
@@ -12833,7 +13490,7 @@ async function saveProviders(configPath, vault, providers, profileConfigPath) {
   let raw;
   let fileExists = true;
   try {
-    raw = await fs14.readFile(targetPath, "utf8");
+    raw = await fs15.readFile(targetPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new ConfigError2({
@@ -13014,7 +13671,7 @@ function projectSavedProviders(providers) {
     return view;
   });
 }
-var probeScrubber = new DefaultSecretScrubber();
+var probeScrubber = new DefaultSecretScrubber2();
 async function probeModelDescriptors(cfg) {
   if (!cfg.baseUrl) return [];
   try {
@@ -13536,6 +14193,7 @@ var CLIENT_COLLABORATION_MESSAGE_TYPES = [
   "collab.resume",
   "collab.grant_control",
   "collab.inject_tool",
+  "mailbox.action",
   "mailbox.agents",
   "mailbox.clear",
   "mailbox.compact",
@@ -13801,6 +14459,7 @@ var SERVER_COLLABORATION_MESSAGE_TYPES = [
   "collab.pause.granted",
   "collab.pause.released",
   "collab.state",
+  "mailbox.action_result",
   "mailbox.agent_registered",
   "mailbox.agents",
   "mailbox.cleared",
@@ -14024,13 +14683,13 @@ function isRegisteredMessageType(type, direction) {
 // src/protocol/decoder.ts
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var MAX_PAYLOAD_DEPTH = 32;
-function inspectValue(value, path29, depth) {
+function inspectValue(value, path30, depth) {
   if (depth > MAX_PAYLOAD_DEPTH) {
-    return { code: "too_deep", message: "Protocol payload exceeds the nesting limit", path: path29 };
+    return { code: "too_deep", message: "Protocol payload exceeds the nesting limit", path: path30 };
   }
   if (value === null || typeof value !== "object") return null;
   for (const key of Object.keys(value)) {
-    const childPath = `${path29}.${key}`;
+    const childPath = `${path30}.${key}`;
     if (FORBIDDEN_KEYS.has(key)) {
       return { code: "unsafe_key", message: `Unsafe protocol key: ${key}`, path: childPath };
     }
@@ -15726,8 +16385,8 @@ function createRouteFamilyDispatcher(options) {
 }
 
 // src/server/shell-open.ts
-import * as fs15 from "node:fs/promises";
-import * as path16 from "node:path";
+import * as fs16 from "node:fs/promises";
+import * as path17 from "node:path";
 import { spawn } from "node:child_process";
 function normalizeShellOpenTarget(target) {
   return target === "terminal" ? "terminal" : "file-manager";
@@ -15738,11 +16397,11 @@ function shellQuote(s) {
 }
 async function handleShellOpen(req, logger, options) {
   try {
-    const resolved = path16.resolve(req.path);
+    const resolved = path17.resolve(req.path);
     if (options?.projectRoot) {
-      const root = path16.resolve(options.projectRoot);
-      const relative5 = path16.relative(root, resolved);
-      const escapes = relative5.startsWith("..") || path16.isAbsolute(relative5);
+      const root = path17.resolve(options.projectRoot);
+      const relative5 = path17.relative(root, resolved);
+      const escapes = relative5.startsWith("..") || path17.isAbsolute(relative5);
       if (escapes) {
         return {
           success: false,
@@ -15750,7 +16409,7 @@ async function handleShellOpen(req, logger, options) {
         };
       }
     }
-    await fs15.access(resolved);
+    await fs16.access(resolved);
     if (METACHAR_REGEX.test(resolved)) {
       return { success: false, message: "Path contains unsupported characters." };
     }
@@ -15801,7 +16460,12 @@ async function handleShellOpen(req, logger, options) {
 }
 
 // src/server/sdd-board-ws-handler.ts
-import { listBoards as listBoards3 } from "@wrongstack/kanban";
+import {
+  enqueueKanbanWorkflowCommand,
+  kanbanWorkflowId,
+  listBoards as listBoards3,
+  listKanbanWorkflowStates
+} from "@wrongstack/kanban";
 import {
   applySddLifecycle,
   extractVerificationCommand,
@@ -15828,16 +16492,17 @@ var SddBoardWebSocketHandler = class {
   clients = /* @__PURE__ */ new Set();
   lifecycle;
   security;
-  diskPollingEnabled;
+  standalonePollingEnabled;
   latest = null;
   poll = null;
   pollInFlight = false;
   unsub = null;
+  disposed = false;
   constructor(boardsDir, events, lifecycle, security) {
     this.store = new SddBoardStore({ baseDir: boardsDir });
     this.lifecycle = lifecycle;
     this.security = security;
-    this.diskPollingEnabled = events === void 0;
+    this.standalonePollingEnabled = events === void 0;
     if (events) {
       const handler = (e) => {
         this.latest = e.snapshot;
@@ -15847,6 +16512,7 @@ var SddBoardWebSocketHandler = class {
     }
   }
   addClient(ws) {
+    if (this.disposed) return;
     const client = { ws, id: crypto.randomUUID() };
     this.clients.add(client);
     const remove = () => {
@@ -15872,7 +16538,7 @@ var SddBoardWebSocketHandler = class {
       return;
     }
     if (msg.type === "sdd.board.list") {
-      const boards = await this.store.list();
+      const boards = await this.listBoardEntries();
       this.broadcast({ type: "sdd.board.list", payload: { boards } });
       return;
     }
@@ -15885,7 +16551,8 @@ var SddBoardWebSocketHandler = class {
       const verificationCommands = [];
       if (action === "set_task_verification") {
         const command = msg.payload?.verificationCommand;
-        if (command !== void 0 && (typeof command !== "string" || command.length > 8192)) return;
+        if (command !== void 0 && (typeof command !== "string" || command.length > 8192))
+          return;
         if (typeof command === "string" && command.trim()) {
           verificationCommands.push({ command, operation: "sdd.set_task_verification" });
         }
@@ -15919,18 +16586,26 @@ var SddBoardWebSocketHandler = class {
         );
         if (!authorization.allowed) return;
       }
-      const runId = msg.payload?.runId ?? this.latest?.runId ?? (await this.store.list())[0]?.runId;
+      const runId = msg.payload?.runId ?? this.latest?.runId ?? (await this.listBoardEntries())[0]?.runId;
       if (runId) {
-        await this.store.appendControl(runId, {
-          ts: Date.now(),
-          type: action,
-          payload: msg.payload
-        });
+        if (this.lifecycle && this.lifecycle.controlTransport !== "legacy-file") {
+          await enqueueKanbanWorkflowCommand(
+            this.lifecycle.projectRoot,
+            kanbanWorkflowId("sdd", runId),
+            { type: action, payload: msg.payload }
+          );
+        } else {
+          await this.store.appendControl(runId, {
+            ts: Date.now(),
+            type: action,
+            payload: msg.payload
+          });
+        }
       }
     }
   }
   /**
-   * Apply a cleanup/rollback/destroy from disk and broadcast a structured
+   * Apply a cleanup/rollback/destroy from durable state and broadcast a structured
    * `sdd.board.lifecycle_result`. Refuses (no-op) while a run is still active —
    * the user must stop it first; the UI gates the buttons on `!active` and the
    * Destroy flow auto-stops then waits before sending `destroy`.
@@ -15939,7 +16614,11 @@ var SddBoardWebSocketHandler = class {
     if (!this.lifecycle) {
       this.broadcast({
         type: "sdd.board.lifecycle_result",
-        payload: { op, ok: false, reason: "Lifecycle operations are not available in this session." }
+        payload: {
+          op,
+          ok: false,
+          reason: "Lifecycle operations are not available in this session."
+        }
       });
       return;
     }
@@ -15955,6 +16634,7 @@ var SddBoardWebSocketHandler = class {
       projectRoot: this.lifecycle.projectRoot,
       paths: this.lifecycle.paths,
       runId,
+      stateTransport: this.lifecycle.stateTransport ?? "kanban",
       revertMerged: payload?.revertMerged === true
     });
     this.broadcast({ type: "sdd.board.lifecycle_result", payload: result });
@@ -15974,31 +16654,40 @@ var SddBoardWebSocketHandler = class {
     }
   }
   dispose() {
+    this.disposed = true;
     this.stopPolling();
     this.unsub?.();
     this.unsub = null;
+    this.clients.clear();
+    this.latest = null;
   }
   // ── internal ────────────────────────────────────────────────────────────
   async pollLatest() {
     if (this.pollInFlight) return;
     this.pollInFlight = true;
     try {
-      const entry = await this.store.latest();
-      if (!entry) return;
-      if (this.latest && this.latest.updatedAt >= entry.updatedAt && this.latest.runId === entry.runId) {
+      const snap = await this.loadLatestSnapshot();
+      if (this.disposed) return;
+      if (!snap) return;
+      if (this.latest && this.latest.updatedAt >= snap.updatedAt && this.latest.runId === snap.runId) {
         return;
       }
-      const snap = await this.store.load(entry.runId);
-      if (snap) {
-        this.latest = snap;
-        this.broadcast({ type: "sdd.board.snapshot", payload: snap });
-      }
+      this.latest = snap;
+      this.broadcast({ type: "sdd.board.snapshot", payload: snap });
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "sdd_board.poll_failed",
+          message: err instanceof Error ? err.message : String(err)
+        })
+      );
     } finally {
       this.pollInFlight = false;
     }
   }
   startPolling() {
-    if (!this.diskPollingEnabled || this.poll !== null || this.clients.size === 0) return;
+    if (!this.standalonePollingEnabled || this.poll !== null || this.clients.size === 0) return;
     this.poll = setInterval(() => void this.pollLatest(), 1e3);
     this.poll.unref?.();
   }
@@ -16008,17 +16697,44 @@ var SddBoardWebSocketHandler = class {
     this.poll = null;
   }
   async sendCurrent(client) {
-    const snap = this.latest ?? await this.loadLatestFromDisk();
+    const snap = this.latest ?? await this.loadLatestSnapshot();
     if (snap) this.send(client, { type: "sdd.board.snapshot", payload: snap });
   }
   async broadcastCurrent() {
-    const snap = this.latest ?? await this.loadLatestFromDisk();
+    const snap = this.latest ?? await this.loadLatestSnapshot();
     if (snap) this.broadcast({ type: "sdd.board.snapshot", payload: snap });
   }
-  async loadLatestFromDisk() {
+  async loadLatestSnapshot() {
+    if (this.usesKanbanState()) {
+      const states = await listKanbanWorkflowStates(this.lifecycle.projectRoot, "sdd:");
+      const snapshots = states.map((state) => state.value).filter(isSddBoardSnapshot).sort((a, b) => b.updatedAt - a.updatedAt);
+      return snapshots[0] ?? null;
+    }
     const entry = await this.store.latest();
     return entry ? this.store.load(entry.runId) : null;
   }
+  async listBoardEntries() {
+    if (!this.usesKanbanState()) return this.store.list();
+    const states = await listKanbanWorkflowStates(this.lifecycle.projectRoot, "sdd:");
+    return states.flatMap((state) => {
+      if (!isSddBoardSnapshot(state.value)) return [];
+      const snapshot = state.value;
+      return [
+        {
+          runId: snapshot.runId,
+          ...snapshot.specId ? { specId: snapshot.specId } : {},
+          title: snapshot.title,
+          status: snapshot.status,
+          total: snapshot.progress.total,
+          completed: snapshot.progress.completed,
+          updatedAt: snapshot.updatedAt
+        }
+      ];
+    });
+  }
+  usesKanbanState() {
+    return Boolean(this.lifecycle && this.lifecycle.stateTransport !== "legacy-file");
+  }
   broadcast(msg) {
     const data = JSON.stringify(msg);
     for (const client of this.clients) {
@@ -16029,17 +16745,20 @@ var SddBoardWebSocketHandler = class {
     sendSerialized(client.ws, JSON.stringify(msg));
   }
 };
+function isSddBoardSnapshot(value) {
+  if (!value || typeof value !== "object") return false;
+  const snapshot = value;
+  return typeof snapshot.runId === "string" && typeof snapshot.title === "string" && typeof snapshot.status === "string" && typeof snapshot.updatedAt === "number" && Array.isArray(snapshot.tasks) && Boolean(snapshot.progress && typeof snapshot.progress.total === "number");
+}
 
 // src/server/sdd-wizard-wiring.ts
-import * as path17 from "node:path";
-import {
-  DefaultTaskStore,
-  TaskTracker
-} from "@wrongstack/core/tasking";
+import * as path18 from "node:path";
+import { DefaultTaskStore, TaskTracker } from "@wrongstack/core/tasking";
 import { ToolValidationError as ToolValidationError5 } from "@wrongstack/core/types";
 import { WorktreeManager as WorktreeManager2 } from "@wrongstack/core/worktree";
 import {
   cleanupStaleSddWorktrees,
+  createKanbanSddSessionPersistence,
   decomposeNonAtomicTasks,
   gatherProjectContext,
   makeAcceptanceCriteriaVerifier,
@@ -16057,7 +16776,7 @@ import {
 } from "@wrongstack/sdd";
 async function startSddRunFromGraph(graph, deps2, config = {}, tracker) {
   const runTracker = tracker ?? (() => {
-    const t = new TaskTracker({ store: new DefaultTaskStore() });
+    const t = new TaskTracker({ store: deps2.taskStore ?? new DefaultTaskStore() });
     t.setGraph(graph);
     return t;
   })();
@@ -16066,7 +16785,8 @@ async function startSddRunFromGraph(graph, deps2, config = {}, tracker) {
   if (worktreesEnabled && await isGitWorkTree(deps2.projectRoot)) {
     void cleanupStaleSddWorktrees({
       projectRoot: deps2.projectRoot,
-      boardsDir: deps2.projectSddBoards
+      boardsDir: deps2.projectSddBoards,
+      stateTransport: "kanban"
     }).catch(() => void 0);
     worktrees = new WorktreeManager2({
       projectRoot: deps2.projectRoot,
@@ -16145,7 +16865,8 @@ function buildSddWizardDeps(opts) {
   }).catch(() => {
     projectContext = "";
   });
-  const sessionPath = opts.paths.projectSddSession ?? path17.join(opts.paths.projectDir, "sdd-session.json");
+  const legacySessionPath = opts.paths.projectSddSession ?? path18.join(opts.paths.projectDir, "sdd-session.json");
+  const sessionPersistence = createKanbanSddSessionPersistence(opts.projectRoot, legacySessionPath);
   const specStore = new SpecStore({ baseDir: opts.paths.projectSpecs });
   const graphStore = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
   const runIsolatedTurn = async (prompt, name2) => {
@@ -16166,7 +16887,7 @@ function buildSddWizardDeps(opts) {
   const makeDriver = () => new SddInterviewDriver({
     specStore,
     graphStore,
-    sessionPath,
+    sessionPersistence,
     projectContext
   });
   const launchFromGraph = async (graph, config, tracker) => {
@@ -16178,6 +16899,7 @@ function buildSddWizardDeps(opts) {
         projectRoot: opts.projectRoot,
         subagentFactory: opts.subagentFactory,
         projectSddBoards: opts.paths.projectSddBoards,
+        taskStore: graphStore,
         registry,
         runIsolatedTurn,
         ...opts.brain ? { brain: opts.brain } : {}
@@ -16247,8 +16969,19 @@ var SddWizardWebSocketHandler = class {
   lastAgentText = "";
   /** Guards against overlapping interview turns (one in flight at a time). */
   busy = false;
-  /** Resolves once project-context gather + disk resume finish. */
+  /** Set when authoritative session state could not be read during bootstrap. */
+  resumeError = null;
+  /** Resolves once project-context gather + durable resume finish. */
   ready;
+  /**
+   * Single-flight slot for the resume probe. `handleMessage` awaits this
+   * when `resumeError` is set, so concurrent frames cannot race the retry
+   * — one probe either clears the gate or re-latches it, then every
+   * queued frame re-checks and proceeds. `null` when no probe is in
+   * flight (or after the probe has settled).
+   */
+  resumeProbe = null;
+  disposed = false;
   async bootstrap() {
     try {
       await this.deps.ensureReady?.();
@@ -16256,26 +16989,37 @@ var SddWizardWebSocketHandler = class {
     }
     await this.tryResume();
   }
-  /** Rehydrate a persisted interview if one exists on disk. */
+  /** Rehydrate a persisted interview if one exists. */
   async tryResume() {
     if (this.driver) return;
     try {
       const driver = this.deps.makeDriver();
-      if (await driver.loadExisting()) {
+      const loaded = await driver.loadExisting();
+      if (this.disposed) return;
+      if (loaded) {
         this.driver = driver;
         this.lastAgentText = driver.getLastAgentText() ?? "";
       }
-    } catch {
+      this.resumeError = null;
+    } catch (error2) {
+      if (this.disposed) return;
       this.driver = null;
       this.lastAgentText = "";
+      this.resumeError = error2 instanceof Error ? error2.message : String(error2);
     }
   }
   addClient(ws) {
+    if (this.disposed) return;
     const client = { ws, id: crypto.randomUUID() };
     this.clients.add(client);
     ws.on("close", () => this.clients.delete(client));
     ws.on("error", () => this.clients.delete(client));
     void this.ready.then(() => {
+      if (this.disposed || !this.clients.has(client)) return;
+      if (this.resumeError) {
+        this.send(client, { type: "sdd.spec.error", payload: { message: this.resumeError } });
+        return;
+      }
       if (this.driver) {
         this.send(client, this.snapshotMsg());
         if (this.lastAgentText) {
@@ -16284,9 +17028,34 @@ var SddWizardWebSocketHandler = class {
       }
     });
   }
+  dispose() {
+    this.disposed = true;
+    this.clients.clear();
+    this.driver = null;
+    this.lastAgentText = "";
+    this.busy = false;
+    this.resumeProbe = null;
+  }
   async handleMessage(msg) {
+    if (this.disposed) return;
     try {
       await this.ready;
+      if (this.resumeError) {
+        if (this.resumeProbe === null) {
+          const probe = Promise.resolve().then(() => this.tryResume());
+          this.resumeProbe = probe;
+          void probe.finally(() => {
+            setTimeout(() => {
+              if (this.resumeProbe === probe) this.resumeProbe = null;
+            }, 0);
+          });
+        }
+        await this.resumeProbe;
+        if (this.resumeError) {
+          this.broadcast({ type: "sdd.spec.error", payload: { message: this.resumeError } });
+          return;
+        }
+      }
       switch (msg.type) {
         case "sdd.spec.start":
           await this.onStart(String(msg.payload?.goal ?? "").trim(), {
@@ -16303,7 +17072,10 @@ var SddWizardWebSocketHandler = class {
           if (this.driver) {
             this.broadcast(this.snapshotMsg());
             if (this.lastAgentText) {
-              this.broadcast({ type: "sdd.spec.agent_text", payload: { text: this.lastAgentText } });
+              this.broadcast({
+                type: "sdd.spec.agent_text",
+                payload: { text: this.lastAgentText }
+              });
             }
           }
           break;
@@ -16483,6 +17255,7 @@ var SddWizardWebSocketHandler = class {
     this.broadcast(this.snapshotMsg());
     try {
       const text = await this.deps.runInterviewTurn(prompt);
+      if (this.disposed) return;
       this.lastAgentText = text;
       if (this.driver) {
         await this.driver.ingestAgentOutput(text);
@@ -16508,6 +17281,7 @@ var SddWizardWebSocketHandler = class {
     }
   }
   send(client, msg) {
+    if (!this.clients.has(client)) return;
     sendSerialized(client.ws, JSON.stringify(msg));
   }
 };
@@ -16517,10 +17291,10 @@ import { recordTaskFileActivity } from "@wrongstack/kanban";
 
 // src/server/setup-events-fleet-broadcaster.ts
 import { watch as fsWatch } from "node:fs";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 function registerSetupEventsFleetBroadcaster(deps2) {
   const { globalConfigPath, wpaths, context, clients, broadcast: broadcast2, onFleetBroadcaster, isDisposed } = deps2;
-  const globalRoot = globalConfigPath ? path18.dirname(globalConfigPath) : void 0;
+  const globalRoot = globalConfigPath ? path19.dirname(globalConfigPath) : void 0;
   if (!globalRoot) return void 0;
   const disposers = [];
   const broadcastSessions = async () => {
@@ -16530,8 +17304,8 @@ function registerSetupEventsFleetBroadcaster(deps2) {
       const sessions = await registry.list();
       const ownEntry = sessions.find((s) => s.pid === process.pid);
       const mySlug = ownEntry?.projectSlug ?? wpaths?.projectSlug;
-      const myRoot = path18.resolve(context.projectRoot);
-      const live = sessions.filter((s) => s.status === "active" || s.status === "idle").filter((s) => mySlug ? s.projectSlug === mySlug : path18.resolve(s.projectRoot) === myRoot).map((s) => ({
+      const myRoot = path19.resolve(context.projectRoot);
+      const live = sessions.filter((s) => s.status === "active" || s.status === "idle").filter((s) => mySlug ? s.projectSlug === mySlug : path19.resolve(s.projectRoot) === myRoot).map((s) => ({
         sessionId: s.sessionId,
         projectName: s.projectName,
         projectSlug: s.projectSlug,
@@ -16721,14 +17495,14 @@ function createSetupEventSessionHelpers(context, sessionBridge) {
 
 // src/server/setup-events-status-watcher.ts
 import { watch as fsWatch2 } from "node:fs";
-import * as fs16 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as fs17 from "node:fs/promises";
+import * as path21 from "node:path";
 
 // src/server/setup-events-watcher.ts
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function statusProjectHashFromWatchFilename(projectsDir, filename) {
   const raw = String(filename);
-  const relative5 = path19.isAbsolute(raw) ? path19.relative(projectsDir, raw) : raw;
+  const relative5 = path20.isAbsolute(raw) ? path20.relative(projectsDir, raw) : raw;
   const parts = relative5.split(/[\\/]+/).filter(Boolean);
   if (parts.length < 2 || parts.at(-1) !== "status.json") return null;
   return parts.at(-2) ?? null;
@@ -16763,7 +17537,7 @@ function logFileWatcherMetrics(metrics) {
 function registerSetupEventsStatusWatcher(deps2) {
   const { wpaths, watcherMetrics, clients, broadcast: broadcast2, on, isDisposed } = deps2;
   if (!wpaths?.projectStatus || !wpaths.globalRoot) return void 0;
-  const projectsDir = path20.join(wpaths.globalRoot, "projects");
+  const projectsDir = path21.join(wpaths.globalRoot, "projects");
   const knownProjectHashes = /* @__PURE__ */ new Set();
   const debounceTimers = /* @__PURE__ */ new Map();
   const DEBOUNCE_MS = 150;
@@ -16808,7 +17582,7 @@ function registerSetupEventsStatusWatcher(deps2) {
   let watcher;
   const startWatcher = async () => {
     try {
-      await fs16.mkdir(projectsDir, { recursive: true });
+      await fs17.mkdir(projectsDir, { recursive: true });
       if (isDisposed()) return;
       watcher = fsWatch2(
         projectsDir,
@@ -16822,8 +17596,8 @@ function registerSetupEventsStatusWatcher(deps2) {
           if (!knownProjectHashes.has(projectHash)) return;
           if (watcherMetrics) watcherMetrics.filesProcessed++;
           try {
-            const targetFile = path20.join(projectsDir, projectHash, "status.json");
-            const content = await fs16.readFile(targetFile, "utf-8");
+            const targetFile = path21.join(projectsDir, projectHash, "status.json");
+            const content = await fs17.readFile(targetFile, "utf-8");
             const statusData = JSON.parse(content);
             scheduleBroadcast(projectHash, statusData);
           } catch {
@@ -16880,8 +17654,8 @@ function registerSetupEventsStatusWatcher(deps2) {
 }
 
 // src/server/setup-events-core-watchers.ts
-import * as fs17 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as fs18 from "node:fs/promises";
+import * as path22 from "node:path";
 function registerSetupEventsCoreWatchers(deps2) {
   const { broadcast: broadcast2, clients, context } = deps2;
   const disposers = [];
@@ -16917,9 +17691,9 @@ function registerSetupEventsClientStatusWriter(deps2) {
     if (wpaths?.projectStatus) {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
-        const dir = path21.dirname(statusFile);
-        await fs17.mkdir(dir, { recursive: true });
-        await fs17.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
+        const dir = path22.dirname(statusFile);
+        await fs18.mkdir(dir, { recursive: true });
+        await fs18.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
       } catch (err) {
         console.error(
           JSON.stringify({
@@ -17274,6 +18048,7 @@ function setupEvents(deps2) {
     });
     pendingConfirms.set(id, {
       resolve: e.resolve,
+      sessionId: e.sessionId,
       decisionSource: e.decisionSource,
       riskTier: e.riskTier,
       boundaryReason: e.boundaryReason,
@@ -17802,6 +18577,9 @@ var SpecsWebSocketHandler = class {
     ws.on("error", () => this.clients.delete(client));
     void this.sendList(client);
   }
+  dispose() {
+    this.clients.clear();
+  }
   async handleMessage(msg) {
     switch (msg.type) {
       case "specs.list":
@@ -17937,14 +18715,15 @@ var SpecsWebSocketHandler = class {
     }
   }
   send(client, msg) {
+    if (!this.clients.has(client)) return;
     sendSerialized(client.ws, JSON.stringify(msg));
   }
 };
 
 // src/server/start-webui.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import * as http2 from "node:http";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 import { createDefaultPipelines } from "@wrongstack/core/agent";
 import { getSharedProjectMailbox as getSharedProjectMailbox4, resolveProjectDir as resolveProjectDir3 } from "@wrongstack/core/coordination";
 import { createCompatibilityTrustBoundary as createCompatibilityTrustBoundary3 } from "@wrongstack/core/security";
@@ -17958,7 +18737,7 @@ import { DEFAULT_CONTEXT_WINDOW_MODE_ID as DEFAULT_CONTEXT_WINDOW_MODE_ID2 } fro
 import {
   expectDefined as expectDefined3,
   sessionScopedPath as sessionScopedPath3,
-  startHeapWatchdog,
+  startSharedHeapWatchdog,
   toErrorMessage as toErrorMessage13,
   wstackGlobalRoot as wstackGlobalRoot2
 } from "@wrongstack/core/utils";
@@ -17968,9 +18747,7 @@ import { ensureSessionShell } from "@wrongstack/tools";
 
 // src/server/backend-services.ts
 import { join as join12 } from "node:path";
-import {
-  Agent
-} from "@wrongstack/core/agent";
+import { Agent } from "@wrongstack/core/agent";
 import {
   BrainDecisionLedger,
   BrainMonitor,
@@ -17982,8 +18759,8 @@ import {
   mailboxSessionTag,
   ObservableBrainArbiter as ObservableBrainArbiterCtor
 } from "@wrongstack/core/coordination";
+import { DEFAULT_TOOLS_CONFIG } from "@wrongstack/core/types";
 import { installDesignStudioMiddleware } from "@wrongstack/core/design";
-import { DEFAULT_TOOLS_CONFIG } from "@wrongstack/core/defaults";
 import {
   AutoCompactionMiddleware as AutoCompactionMiddlewareCtor,
   createBrainRuntime,
@@ -17993,7 +18770,9 @@ import {
 } from "@wrongstack/core/execution";
 import { TOKENS } from "@wrongstack/core/kernel";
 import { SessionMemoryConsolidator } from "@wrongstack/core/storage";
-import { resolveContextWindowPolicy as resolveContextWindowPolicy2 } from "@wrongstack/core/types";
+import {
+  resolveContextWindowPolicy as resolveContextWindowPolicy2
+} from "@wrongstack/core/types";
 import {
   estimateRequestTokensCalibrated,
   toErrorMessage as toErrorMessage9
@@ -18385,9 +19164,9 @@ function clampDim(value, fallback) {
 
 // src/server/worktree-ws-handler.ts
 import { join as join11, resolve as resolve12, sep as sep5 } from "node:path";
+import { toErrorMessage as toErrorMessage8 } from "@wrongstack/core/utils";
 import { WorktreeManager as WorktreeManager3 } from "@wrongstack/core/worktree";
 import { cleanupStaleSddWorktrees as cleanupStaleSddWorktrees2 } from "@wrongstack/sdd";
-import { toErrorMessage as toErrorMessage8 } from "@wrongstack/core/utils";
 var MAX_ACTIVITY = 6;
 var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["allocating", "active", "committing", "merging"]);
 var MANAGED_BRANCH_RE = /^wstack\/ap\/[A-Za-z0-9._/-]+$/;
@@ -18406,6 +19185,20 @@ var WorktreeWebSocketHandler = class {
   baseBranch = "";
   broadcastInterval = null;
   offs = [];
+  /**
+   * Single-flight guard for orphan scans. Two concurrent `scanAndBroadcast()`
+   * calls would race: the first call reads `wt.listManaged()`, then the
+   * second call's mutation completes (e.g. `removeOne`), then the first call
+   * broadcasts a stale orphan list — the user sees a row persist and clicks
+   * Remove a second time, hitting "remove failed (not a managed worktree?)".
+   *
+   * We coalesce concurrent triggers: while a scan is in flight, additional
+   * callers are remembered as "need a re-scan" and exactly one follow-up
+   * scan runs after the in-flight one finishes. The re-scan picks up any
+   * mutations that landed during the previous scan's `listManaged()` window.
+   */
+  scanInFlight = null;
+  scanRescanNeeded = false;
   addClient(ws) {
     this.clients.add(ws);
     ws.on("close", () => this.clients.delete(ws));
@@ -18424,7 +19217,10 @@ var WorktreeWebSocketHandler = class {
       return true;
     }
     if (msg.type === "worktree.remove") {
-      await this.removeOne(msg.payload?.["dir"], msg.payload?.["branch"]);
+      await this.removeOne(
+        msg.payload?.["dir"],
+        msg.payload?.["branch"]
+      );
       return true;
     }
     if (msg.type === "worktree.merge") {
@@ -18432,7 +19228,10 @@ var WorktreeWebSocketHandler = class {
       return true;
     }
     if (msg.type === "worktree.diff") {
-      await this.diffOne(msg.payload?.["dir"], msg.payload?.["baseBranch"]);
+      await this.diffOne(
+        msg.payload?.["dir"],
+        msg.payload?.["baseBranch"]
+      );
       return true;
     }
     return false;
@@ -18441,6 +19240,10 @@ var WorktreeWebSocketHandler = class {
     for (const off of this.offs) off();
     this.offs.length = 0;
     this.stopBroadcast();
+    this.clients.clear();
+    this.handles.clear();
+    this.baseBranch = "";
+    this.scanRescanNeeded = false;
   }
   // ── orphan management ─────────────────────────────────────────────────────
   /** Absolute managed-worktrees root for this project. */
@@ -18461,12 +19264,43 @@ var WorktreeWebSocketHandler = class {
     }
     return live;
   }
+  /**
+   * Coalesced orphan scan entry point. Multiple concurrent callers share one
+   * in-flight scan; if a caller arrives during a scan, a single follow-up
+   * scan is scheduled to pick up mutations that landed mid-scan. Returns the
+   * shared promise so `await this.scanAndBroadcast()` still works for callers
+   * that want to chain after the next broadcast.
+   */
+  scanAndBroadcast() {
+    if (this.scanInFlight) {
+      this.scanRescanNeeded = true;
+      return this.scanInFlight;
+    }
+    this.scanInFlight = this.runScanAndMaybeRescan();
+    return this.scanInFlight;
+  }
+  /**
+   * Run the actual scan, then drain a pending re-scan request if one came in
+   * during the scan. The re-scan is bounded (one follow-up) — additional
+   * requests that arrive during the follow-up coalesce into the next one.
+   */
+  async runScanAndMaybeRescan() {
+    try {
+      await this.runScanOnce();
+      while (this.scanRescanNeeded) {
+        this.scanRescanNeeded = false;
+        await this.runScanOnce();
+      }
+    } finally {
+      this.scanInFlight = null;
+    }
+  }
   /**
    * Scan the disk for managed worktrees/branches NOT owned by a live in-session
    * run and broadcast them as orphans, with whether it is safe to clean now.
    * No-op (empty inventory) when management deps were not wired.
    */
-  async scanAndBroadcast() {
+  async runScanOnce() {
     if (!this.management) {
       this.broadcast({ type: "worktree.orphans", payload: { orphans: [], canClean: false } });
       return;
@@ -18522,7 +19356,8 @@ var WorktreeWebSocketHandler = class {
     }
     const res = await cleanupStaleSddWorktrees2({
       projectRoot: this.management.projectRoot,
-      boardsDir: this.management.boardsDir
+      boardsDir: this.management.boardsDir,
+      stateTransport: "kanban"
     });
     if (res.skippedReason) {
       this.broadcast({
@@ -18535,26 +19370,45 @@ var WorktreeWebSocketHandler = class {
     for (const [id, h] of [...this.handles]) {
       if (!ACTIVE_STATUSES.has(h.status)) this.handles.delete(id);
     }
-    this.broadcast({ type: "worktree.cleanup_result", payload: { ok: true, removed: res.removed } });
+    this.broadcast({
+      type: "worktree.cleanup_result",
+      payload: { ok: true, removed: res.removed }
+    });
     this.broadcastState();
     await this.scanAndBroadcast();
   }
   /** Remove/discard ONE worktree + branch. Refused while a live run owns it. */
   async removeOne(dir, branch) {
     if (!this.management || !dir && !branch) {
-      this.broadcast({ type: "worktree.cleanup_result", payload: { ok: false, removed: 0, reason: "nothing to remove" } });
+      this.broadcast({
+        type: "worktree.cleanup_result",
+        payload: { ok: false, removed: 0, reason: "nothing to remove" }
+      });
       return;
     }
     if (branch && !MANAGED_BRANCH_RE.test(branch)) {
-      this.broadcast({ type: "worktree.cleanup_result", payload: { ok: false, removed: 0, reason: "not a managed worktree branch" } });
+      this.broadcast({
+        type: "worktree.cleanup_result",
+        payload: { ok: false, removed: 0, reason: "not a managed worktree branch" }
+      });
       return;
     }
     if (dir && !this.underRoot(dir)) {
-      this.broadcast({ type: "worktree.cleanup_result", payload: { ok: false, removed: 0, reason: "path is outside the managed worktrees root" } });
+      this.broadcast({
+        type: "worktree.cleanup_result",
+        payload: { ok: false, removed: 0, reason: "path is outside the managed worktrees root" }
+      });
       return;
     }
     if (branch && this.liveActiveBranches().has(branch)) {
-      this.broadcast({ type: "worktree.cleanup_result", payload: { ok: false, removed: 0, reason: "a run is live on this worktree \u2014 stop it first" } });
+      this.broadcast({
+        type: "worktree.cleanup_result",
+        payload: {
+          ok: false,
+          removed: 0,
+          reason: "a run is live on this worktree \u2014 stop it first"
+        }
+      });
       return;
     }
     let removed = false;
@@ -18563,31 +19417,54 @@ var WorktreeWebSocketHandler = class {
       ({ removed } = await wt.removeOne(dir, branch));
     }
     for (const [id, h] of [...this.handles]) {
-      if (branch && h.branch === branch || dir && h.handleId && dir.endsWith(h.handleId)) this.handles.delete(id);
+      if (branch && h.branch === branch || dir && h.handleId && dir.endsWith(h.handleId))
+        this.handles.delete(id);
     }
-    this.broadcast({ type: "worktree.cleanup_result", payload: { ok: removed, removed: removed ? 1 : 0, reason: removed ? void 0 : "remove failed (not a managed worktree?)" } });
+    this.broadcast({
+      type: "worktree.cleanup_result",
+      payload: {
+        ok: removed,
+        removed: removed ? 1 : 0,
+        reason: removed ? void 0 : "remove failed (not a managed worktree?)"
+      }
+    });
     this.broadcastState();
     await this.scanAndBroadcast();
   }
   /** Squash-merge ONE branch into base. Refused while a live run owns it. */
   async mergeBranch(branch) {
     if (!this.management || !branch) {
-      this.broadcast({ type: "worktree.merge_result", payload: { ok: false, branch: branch ?? "", reason: "no branch" } });
+      this.broadcast({
+        type: "worktree.merge_result",
+        payload: { ok: false, branch: branch ?? "", reason: "no branch" }
+      });
       return;
     }
     if (!MANAGED_BRANCH_RE.test(branch)) {
-      this.broadcast({ type: "worktree.merge_result", payload: { ok: false, branch, reason: "not a managed worktree branch" } });
+      this.broadcast({
+        type: "worktree.merge_result",
+        payload: { ok: false, branch, reason: "not a managed worktree branch" }
+      });
       return;
     }
     if (this.liveActiveBranches().has(branch)) {
-      this.broadcast({ type: "worktree.merge_result", payload: { ok: false, branch, reason: "a run is live on this worktree \u2014 stop it first" } });
+      this.broadcast({
+        type: "worktree.merge_result",
+        payload: { ok: false, branch, reason: "a run is live on this worktree \u2014 stop it first" }
+      });
       return;
     }
     const wt = new WorktreeManager3({ projectRoot: this.management.projectRoot });
     const res = await wt.mergeBranch(branch);
     this.broadcast({
       type: "worktree.merge_result",
-      payload: { ok: res.ok, branch, conflict: res.conflict, conflictFiles: res.conflictFiles, reason: res.reason }
+      payload: {
+        ok: res.ok,
+        branch,
+        conflict: res.conflict,
+        conflictFiles: res.conflictFiles,
+        reason: res.reason
+      }
     });
     await this.scanAndBroadcast();
   }
@@ -18629,8 +19506,14 @@ var WorktreeWebSocketHandler = class {
       }),
       on("worktree.committed", (p) => {
         const e = p;
-        this.patch(e.handleId, { status: "committing", insertions: e.insertions, deletions: e.deletions, files: e.files });
-        if (e.committed) this.activity(e.handleId, "committed", `+${e.insertions}/-${e.deletions} (${e.files}f)`);
+        this.patch(e.handleId, {
+          status: "committing",
+          insertions: e.insertions,
+          deletions: e.deletions,
+          files: e.files
+        });
+        if (e.committed)
+          this.activity(e.handleId, "committed", `+${e.insertions}/-${e.deletions} (${e.files}f)`);
         this.broadcastState();
       }),
       on("worktree.merged", (p) => {
@@ -18671,10 +19554,15 @@ var WorktreeWebSocketHandler = class {
   activity(id, kind, text) {
     const cur = this.handles.get(id);
     if (cur) {
-      const recentActivity = [...cur.recentActivity, { kind, text, at: Date.now() }].slice(-MAX_ACTIVITY);
+      const recentActivity = [...cur.recentActivity, { kind, text, at: Date.now() }].slice(
+        -MAX_ACTIVITY
+      );
       this.handles.set(id, { ...cur, recentActivity });
     }
-    this.broadcast({ type: "worktree.event", payload: { kind, handleId: id, text, at: Date.now() } });
+    this.broadcast({
+      type: "worktree.event",
+      payload: { kind, handleId: id, text, at: Date.now() }
+    });
   }
   stateMessage() {
     return {
@@ -18753,7 +19641,13 @@ async function createAgentServices(input) {
           minImportance: config.Sage?.inject?.minImportance,
           repeatCooldownMs: config.Sage?.inject?.repeatCooldownMs,
           verifyOnMutation: config.Sage?.hygiene?.autoOnFileChange,
-          triggers: config.Sage?.inject?.triggers
+          triggers: config.Sage?.inject?.triggers,
+          // Resolve the live session so retrieval and cooldown are session-scoped
+          // (matching the CLI wiring in wiring/sage.ts). Without this, the
+          // middleware falls back to ctx.session.id for cooldown but passes
+          // undefined to retrieval, causing owned session-scoped memories to be
+          // silently excluded from tool-call injection.
+          getSessionId: () => input.sessionGetter().id
         })
       );
     }
@@ -18877,6 +19771,7 @@ async function createAgentServices(input) {
     perIterationOutputCapBytes: config.tools?.perIterationOutputCapBytes ?? DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
     tracer: void 0
   });
+  input.installToolBoundary?.(pipelines);
   const webuiLogger = container.resolve(TOKENS.Logger);
   void discoverMailboxBridgeForWebui({
     projectRoot,
@@ -18981,33 +19876,35 @@ async function createAgentServices(input) {
     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 : ""
-    })
-  );
+  const brainLogOffs = [
+    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 : ""
+      })
+    )
+  ];
   const brainMailbox = getSharedProjectMailbox2(wpaths.projectDir, events);
   brainMonitor = new BrainMonitor({
     events,
@@ -19087,7 +19984,8 @@ async function createAgentServices(input) {
         // subagent's fallback extension's tracker hooks are undefined and
         // round-robin keeps reassigning the doomed model. Mirrors the CLI
         // factory wiring at host-subagent-factory.ts:337.
-        statusTracker: container.safeResolve(TOKENS.ProviderModelStatusTracker)
+        statusTracker: container.safeResolve(TOKENS.ProviderModelStatusTracker),
+        ...input.installToolBoundary ? { installToolBoundary: input.installToolBoundary } : {}
       }),
       paths: {
         projectSpecs: wpaths.projectSpecs,
@@ -19119,6 +20017,19 @@ async function createAgentServices(input) {
       getActiveSessionId: () => context.session.id
     }
   );
+  let realtimeHandlersDisposed = false;
+  const disposeRealtimeHandlers = () => {
+    if (realtimeHandlersDisposed) return;
+    realtimeHandlersDisposed = true;
+    for (const off of brainLogOffs) off();
+    goalHandler.dispose();
+    sddBoardHandler.dispose();
+    sddWizardHandler.dispose();
+    specsHandler.dispose();
+    worktreeHandler.dispose();
+    terminalHandler.dispose();
+    collabHandler.dispose();
+  };
   return {
     collabBus,
     compactor,
@@ -19144,12 +20055,16 @@ async function createAgentServices(input) {
     worktreeHandler,
     terminalHandler,
     collabHandler,
+    disposeRealtimeHandlers,
     updateAutoCompactionMaxContext
   };
 }
 
 // src/server/connection-handler.ts
-var RATE_LIMIT_MESSAGES = Number.parseInt(process.env["WEBUI_RATE_LIMIT"] ?? "0", 10);
+var DEFAULT_WS_RATE_LIMIT = 600;
+var rawRateLimit = process.env["WEBUI_RATE_LIMIT"];
+var parsedRateLimit = rawRateLimit ? Number.parseInt(rawRateLimit, 10) : DEFAULT_WS_RATE_LIMIT;
+var RATE_LIMIT_MESSAGES = Number.isFinite(parsedRateLimit) && parsedRateLimit >= 0 ? parsedRateLimit : DEFAULT_WS_RATE_LIMIT;
 var VERBOSE_WS_LOGGING = process.env["WEBUI_VERBOSE_WS"] === "1" || process.env["WEBUI_VERBOSE_WS"] === "true";
 function readRemoteAddress(ws) {
   const socket = ws._socket;
@@ -19229,8 +20144,74 @@ function createConnectionHandler(options) {
   };
 }
 
+// src/server/governance-runtime.ts
+import {
+  createGovernanceMutationSnapshotBridge
+} from "@wrongstack/runtime/governance-mutation-snapshot-bridge";
+import { sanitizeGovernanceMessage } from "@wrongstack/runtime/governance-sanitize";
+var WRONGSTACK_GOVERNANCE_ENV = "WRONGSTACK_GOVERNANCE";
+var DEFAULT_DEPENDENCIES = {
+  load: () => import("@wrongstack/runtime/governance-bootstrap"),
+  createMutationBridge: createGovernanceMutationSnapshotBridge
+};
+function webUiGovernanceRuntimeEnabled(environment) {
+  return environment[WRONGSTACK_GOVERNANCE_ENV]?.trim() === "1";
+}
+async function setupWebUiGovernance(input, dependencies = DEFAULT_DEPENDENCIES) {
+  if (!webUiGovernanceRuntimeEnabled(input.environment)) return void 0;
+  let loaded;
+  try {
+    loaded = await dependencies.load();
+  } catch (error2) {
+    input.logger.warn("governance: standalone WebUI runtime module unavailable", {
+      message: sanitizeGovernanceMessage(error2 instanceof Error ? error2.message : String(error2))
+    });
+    return void 0;
+  }
+  let result;
+  try {
+    result = await loaded.bootstrapGovernanceRuntime({
+      projectRoot: input.projectRoot,
+      projectId: input.projectId,
+      adminClientId: `webui-control-${process.pid}-${input.sessionId}`,
+      modelClientId: `webui-model-${input.sessionId}`,
+      modelCapabilities: ["task_read", "command_submit", "shadow_observe"]
+    });
+  } catch (error2) {
+    input.logger.warn("governance: standalone WebUI bootstrap failed open", {
+      message: sanitizeGovernanceMessage(error2 instanceof Error ? error2.message : String(error2))
+    });
+    return void 0;
+  }
+  if (result.mode !== "governed") {
+    input.contextMeta["governance"] = result;
+    input.logger.warn(`governance: standalone WebUI legacy fallback (${result.code})`, {
+      phase: result.phase,
+      cleanup: result.cleanup,
+      message: result.message
+    });
+    return void 0;
+  }
+  const snapshot = result.handle.snapshot();
+  input.contextMeta["governance"] = snapshot;
+  input.logger.info(`governance: ${snapshot.source} standalone WebUI control plane`);
+  const mutationSnapshots = dependencies.createMutationBridge({
+    events: input.events,
+    sink: result.handle,
+    captureWorkspaceCheckpoint: input.captureWorkspaceCheckpoint,
+    logger: input.logger
+  });
+  return Object.freeze({
+    installToolBoundary: (pipelines) => mutationSnapshots.installToolBoundary(pipelines),
+    close: async () => {
+      await mutationSnapshots.close();
+      return result.handle.close();
+    }
+  });
+}
+
 // src/server/message-dispatcher.ts
-import path22 from "node:path";
+import path23 from "node:path";
 function createMessageDispatcher(opts) {
   const { state, deps: deps2, routes, promptsCtx, codebaseIndexing, runLock, pendingConfirms } = opts;
   function makeWorklistContext() {
@@ -19251,7 +20232,7 @@ function createMessageDispatcher(opts) {
       skillLoader: deps2.skillLoader,
       skillInstaller: deps2.skillInstaller,
       projectRoot,
-      projectSkillsDir: path22.join(projectRoot, ".wrongstack", "skills"),
+      projectSkillsDir: path23.join(projectRoot, ".wrongstack", "skills"),
       globalSkillsDir: deps2.wpaths.globalSkills
     };
   }
@@ -19503,7 +20484,7 @@ function createMessageDispatcher(opts) {
 
 // src/server/pre-context-services.ts
 import { createRequire as createRequire3 } from "node:module";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 import { Context, DefaultSystemPromptBuilder } from "@wrongstack/core/agent";
 import {
   getSharedProjectMailbox as getSharedProjectMailbox3,
@@ -19557,8 +20538,8 @@ import { configureDangerBypass, configureExecPolicy } from "@wrongstack/tools";
 import { attachSessionKanbanMirror, hydrateSessionKanban } from "@wrongstack/tools/session-kanban";
 
 // src/server/model-auto-discovery.ts
-import * as fs18 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as fs19 from "node:fs/promises";
+import * as path24 from "node:path";
 import { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from "@wrongstack/providers";
 function isOverlayRegistry(value) {
   return !!value && typeof value === "object" && typeof value.mergeOverlay === "function";
@@ -19584,7 +20565,7 @@ function eligibleProviders(config) {
 }
 async function readCache(file) {
   try {
-    return JSON.parse(await fs18.readFile(file, "utf8"));
+    return JSON.parse(await fs19.readFile(file, "utf8"));
   } catch {
     return {};
   }
@@ -19594,7 +20575,7 @@ async function discoverAndMergeWebuiProviders(opts) {
   if (!isOverlayRegistry(registry)) return;
   const targets = eligibleProviders(opts.config);
   if (targets.length === 0) return;
-  const cacheFile = path23.join(opts.cacheDir, "discovered-models-cache.json");
+  const cacheFile = path24.join(opts.cacheDir, "discovered-models-cache.json");
   const cache2 = await readCache(cacheFile);
   let cacheDirty = false;
   await Promise.all(
@@ -19631,8 +20612,8 @@ async function discoverAndMergeWebuiProviders(opts) {
   );
   if (cacheDirty) {
     try {
-      await fs18.mkdir(path23.dirname(cacheFile), { recursive: true });
-      await fs18.writeFile(cacheFile, JSON.stringify(cache2), "utf8");
+      await fs19.mkdir(path24.dirname(cacheFile), { recursive: true });
+      await fs19.writeFile(cacheFile, JSON.stringify(cache2), "utf8");
     } catch {
       opts.logger?.debug?.("provider auto-discovery cache write failed");
     }
@@ -19728,7 +20709,7 @@ function resolveSetupProvider(opts) {
 }
 
 // src/server/standalone-session-identity.ts
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import {
   AgentStatusTracker,
   FleetNotifier,
@@ -19747,7 +20728,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
   let activeTarget = {
     projectSlug: paths.projectSlug,
     projectRoot: paths.projectRoot,
-    projectName: path24.basename(paths.projectRoot),
+    projectName: path25.basename(paths.projectRoot),
     workingDir: opts.workingDir
   };
   let pendingClaim;
@@ -19978,7 +20959,7 @@ async function createPreContextServices(input) {
     await discoverAndMergeWebuiProviders({
       config,
       registry: modelsRegistry,
-      cacheDir: path25.dirname(wpaths.modelsCache),
+      cacheDir: path26.dirname(wpaths.modelsCache),
       logger
     });
   } catch (err) {
@@ -20030,7 +21011,7 @@ async function createPreContextServices(input) {
   configureChildEnvGitIdentity(config.git?.identity ?? null);
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const mcpTokenStore = new MCPVaultTokenStore(
-    path25.join(wpaths.projectDir, "mcp-auth.json"),
+    path26.join(wpaths.projectDir, "mcp-auth.json"),
     vault
   );
   const mcpAuthorizationManager = new MCPAuthorizationManager({ store: mcpTokenStore });
@@ -20136,7 +21117,7 @@ async function createPreContextServices(input) {
   };
   const skillLoader = config.features.skills ? new DefaultSkillLoader({ paths: wpaths }) : void 0;
   const skillInstaller = config.features.skills ? new SkillInstaller({
-    manifestPath: path25.join(wpaths.configDir, "installed-skills.json"),
+    manifestPath: path26.join(wpaths.configDir, "installed-skills.json"),
     projectSkillsDir: wpaths.inProjectSkills,
     globalSkillsDir: wpaths.globalSkills,
     projectHash: wpaths.projectHash,
@@ -20146,8 +21127,8 @@ async function createPreContextServices(input) {
   const bundledPromptsDir = promptsEnabled ? (() => {
     try {
       const req = createRequire3(import.meta.url);
-      return path25.join(
-        path25.dirname(req.resolve("@wrongstack/core/package.json")),
+      return path26.join(
+        path26.dirname(req.resolve("@wrongstack/core/package.json")),
         "data",
         "prompts"
       );
@@ -20251,7 +21232,7 @@ async function createPreContextServices(input) {
 }
 
 // src/server/routes.ts
-import path26 from "node:path";
+import path27 from "node:path";
 import { makeProviderFromConfig as makeProviderFromConfig2, withCatalogCapabilities } from "@wrongstack/providers";
 
 // src/server/mode-handlers.ts
@@ -20543,7 +21524,7 @@ function buildRoutes(state, deps2, cb) {
   };
   const mailboxRoutes = createMailboxRouteHandlers({
     getProjectRoot: state.getProjectRoot,
-    getGlobalRoot: () => path26.dirname(deps2.globalConfigPath),
+    getGlobalRoot: () => path27.dirname(deps2.globalConfigPath),
     events: deps2.events
   });
   const mcpRoutes = {
@@ -20616,7 +21597,7 @@ function buildRoutes(state, deps2, cb) {
 }
 
 // src/server/server-runtime.ts
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer } from "ws";
@@ -20677,7 +21658,7 @@ function createSessionStartPayload(g) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path27.basename(projectRoot) || projectRoot,
+      projectName: path28.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: g.getWorkingDir(),
       mode: g.getModeId(),
@@ -20765,13 +21746,13 @@ function armEvents(wssPrimary, wssSecondary, wsHost, httpPort, setupInput, watch
   };
 }
 function resolveWebuiDistDir(fromUrl, explicitDistDir) {
-  if (explicitDistDir) return path27.resolve(explicitDistDir);
+  if (explicitDistDir) return path28.resolve(explicitDistDir);
   try {
     const requireFromHere2 = createRequire4(fromUrl);
     const serverEntry = requireFromHere2.resolve("@wrongstack/webui");
-    return path27.dirname(serverEntry);
+    return path28.dirname(serverEntry);
   } catch {
-    return path27.resolve(path27.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
+    return path28.resolve(path28.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
   }
 }
 function startHttpServer(opts) {
@@ -20933,6 +21914,17 @@ async function startWebUI(opts = {}) {
   const prefSnapshot2 = () => prefSnapshot(context.meta);
   const persistPrefsToConfig2 = async (payload) => persistPrefsToConfig(prefHelperDeps, configWriteLock, payload);
   const trustBoundary = opts.trustBoundary ?? createCompatibilityTrustBoundary3({ policyId: "webui-trusted-host-compat-v1" });
+  const governanceHandle = opts.installToolBoundary === void 0 ? await setupWebUiGovernance({
+    environment: process.env,
+    projectRoot,
+    projectId: wpaths.projectSlug,
+    sessionId: session.id,
+    contextMeta: context.meta,
+    events,
+    logger,
+    captureWorkspaceCheckpoint: async () => sessionStore.captureWorkspaceCheckpoint?.(session.id, 0)
+  }) : void 0;
+  const installToolBoundary = opts.installToolBoundary ?? governanceHandle?.installToolBoundary;
   const agentServices = await createAgentServices({
     trustBoundary,
     config,
@@ -20955,6 +21947,7 @@ async function startWebUI(opts = {}) {
     skillInstaller,
     tokenCounter,
     pipelines: createDefaultPipelines(),
+    ...installToolBoundary ? { installToolBoundary } : {},
     modelCapabilitiesRef,
     sessionGetter: () => session,
     sessionReader,
@@ -20985,6 +21978,7 @@ async function startWebUI(opts = {}) {
     worktreeHandler,
     terminalHandler,
     collabHandler,
+    disposeRealtimeHandlers,
     updateAutoCompactionMaxContext
   } = agentServices;
   if (typeof context.meta["yolo"] === "boolean") {
@@ -21035,7 +22029,7 @@ async function startWebUI(opts = {}) {
       const input = toLanguagePackageInput(operation, workspace);
       const use = {
         type: "tool_use",
-        id: `techstack-remediation-${randomUUID5()}`,
+        id: `techstack-remediation-${randomUUID4()}`,
         name: "language_package",
         input: { ...input }
       };
@@ -21163,21 +22157,21 @@ async function startWebUI(opts = {}) {
     });
   }
   async function touchProjectEntry(root, workDir) {
-    const resolved = path28.resolve(root);
+    const resolved = path29.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = manifest.projects.find((p) => path28.resolve(p.root) === resolved);
+    const existing = manifest.projects.find((p) => path29.resolve(p.root) === resolved);
     if (existing) {
       existing.lastSeen = now;
-      if (workDir) existing.lastWorkingDir = path28.resolve(workDir);
+      if (workDir) existing.lastWorkingDir = path29.resolve(workDir);
     } else {
       manifest.projects.push({
-        name: path28.basename(resolved),
+        name: path29.basename(resolved),
         root: resolved,
         slug: generateProjectSlug(resolved),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: workDir ? path28.resolve(workDir) : void 0
+        lastWorkingDir: workDir ? path29.resolve(workDir) : void 0
       });
     }
     await saveManifest(manifest, globalConfigPath);
@@ -21304,7 +22298,8 @@ async function startWebUI(opts = {}) {
           patchConfig(state.getConfig(), {
             providers: snapshot.providers,
             ...snapshot.apiKey !== void 0 ? { apiKey: snapshot.apiKey } : {},
-            ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {}
+            ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {},
+            fallbackBridge: snapshot.fallbackBridge ?? ""
           })
         );
         deps2.configStore.update({
@@ -21312,6 +22307,7 @@ async function startWebUI(opts = {}) {
           ...snapshot.apiKey !== void 0 ? { apiKey: snapshot.apiKey } : {},
           ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {},
           ...snapshot.fallbackModels !== void 0 ? { fallbackModels: snapshot.fallbackModels } : {},
+          fallbackBridge: snapshot.fallbackBridge ?? "",
           ...snapshot.fallbackProfiles !== void 0 ? { fallbackProfiles: snapshot.fallbackProfiles } : {},
           ...snapshot.favoriteModels !== void 0 ? { favoriteModels: snapshot.favoriteModels } : {},
           ...snapshot.favoriteModelsOnly !== void 0 ? { favoriteModelsOnly: snapshot.favoriteModelsOnly } : {},
@@ -21354,7 +22350,20 @@ async function startWebUI(opts = {}) {
     );
     credentialWatcherClose = credentialWatcher.close;
   }
-  const stopHeapWatchdog = startHeapWatchdog();
+  const stopHeapWatchdog = startSharedHeapWatchdog({
+    collectStats: () => ({
+      surface: opts.surface ?? "webui",
+      sessionId: context.session.id,
+      messages: context.state.messages.length,
+      messageEstimatedTokens: context.state.messages.reduce(
+        (sum, message) => sum + (message._estTokens ?? 0),
+        0
+      ),
+      webClients: clients.size,
+      pendingConfirms: pendingConfirms.size,
+      runActive: runLockControl.get() !== null
+    })
+  });
   const routes = buildRoutes(state, deps2, cb);
   const handleMessage = createMessageDispatcher({
     state,
@@ -21432,6 +22441,13 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
       await todosCheckpoint.detach();
       await stopHeapWatchdog();
       credentialWatcherClose?.();
+      disposeRealtimeHandlers();
+      const governanceCleanup = await governanceHandle?.close();
+      if (governanceCleanup && !governanceCleanup.ok) {
+        logger.warn(`governance: standalone WebUI ${governanceCleanup.action} cleanup failed`, {
+          message: governanceCleanup.message
+        });
+      }
       brainMonitor.stop();
       await agentServices.brainLedger?.stop().catch(() => {
       });
@@ -21455,7 +22471,7 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
       await memoryStore.dispose().catch(
         (err) => logger.warn(`sage connection disposal failed: ${toErrorMessage13(err)}`)
       );
-      await unregisterInstance(process.pid, path28.dirname(globalConfigPath));
+      await unregisterInstance(process.pid, path29.dirname(globalConfigPath));
     }
   });
 }
@@ -21548,7 +22564,7 @@ if (argv.includes("--help") || argv.includes("-h")) {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
-  const open = argv.includes("--open") || argv.includes("-o") || process.env["WEBUI_OPEN"] === "1";
+  const open2 = argv.includes("--open") || argv.includes("-o") || process.env["WEBUI_OPEN"] === "1";
   const requireToken = argv.includes("--require-token") || envFlag2("WEBUI_REQUIRE_TOKEN");
   console.log(`[WebUI] Starting standalone server on ${wsHost} (http:${httpPort})...`);
   startWebUI({
@@ -21558,7 +22574,7 @@ if (argv.includes("--help") || argv.includes("-h")) {
     publicUrl,
     publicWsUrl,
     requireToken,
-    open,
+    open: open2,
     distDir
   }).catch((err) => {
     console.error(JSON.stringify({