@wrongstack/webui-server 0.297.0 → 0.298.0

package/dist/index.js

@@ -8,6 +8,7 @@ function isDestructivePendingConfirm(confirm) {
 function resolveYoloEligiblePendingConfirms(pendingConfirms) {
   for (const [id, confirm] of pendingConfirms) {
     if (confirm.boundaryReason) continue;
+    if (isDestructivePendingConfirm(confirm)) continue;
     pendingConfirms.delete(id);
     confirm.resolve("yes");
   }
@@ -71,7 +72,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",
@@ -92,14 +104,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",
@@ -221,7 +258,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`;
@@ -245,9 +290,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")) {
@@ -261,6 +313,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"];
@@ -862,6 +918,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) {
@@ -898,6 +1006,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);
@@ -934,6 +1045,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) {
@@ -971,7 +1083,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");
@@ -1287,7 +1399,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);
@@ -1304,7 +1425,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);
@@ -1312,16 +1433,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
@@ -1612,6 +1736,7 @@ var CollaborationWebSocketHandler = class {
     this.offs.length = 0;
     this.stopBroadcast();
     this.clients.clear();
+    this.bySession.clear();
   }
   // ── Inbound client messages ────────────────────────────────────────────
   /**
@@ -2815,6 +2940,7 @@ import {
   materializeTokens,
   recordKitChoice,
   recordOverrides,
+  resolveMaterializeTarget,
   resolveSemanticTune,
   runDesignVerify,
   setActiveKit,
@@ -3026,7 +3152,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, {
@@ -3179,7 +3305,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);
@@ -3683,10 +3831,11 @@ function readZipEntries(archive) {
     const dataStart = nameStart + nameLength + extraLength;
     const dataEnd = dataStart + compressedSize;
     if (dataEnd > buffer.length) throw new Error("Truncated ZIP entry.");
-    const name2 = buffer.subarray(nameStart, nameStart + nameLength).toString("utf8");
-    if (!isSafeZipPath(name2)) throw new Error(`Unsafe ZIP entry path: ${name2}`);
+    const rawName = buffer.subarray(nameStart, nameStart + nameLength).toString("utf8");
+    const name2 = normalizeZipPath(rawName);
     const compressed = buffer.subarray(dataStart, dataEnd);
-    const data = method === 0 ? Buffer.from(compressed) : method === 8 ? inflateRawSync(compressed) : void 0;
+    const inflateLimit = Math.min(expectedSize, maxEntryBytes) + 1;
+    const data = method === 0 ? Buffer.from(compressed) : method === 8 ? inflateRawSync(compressed, { maxOutputLength: inflateLimit }) : void 0;
     if (!data) throw new Error(`Unsupported ZIP compression method: ${method}`);
     if (data.length !== expectedSize) throw new Error(`ZIP size mismatch for ${name2}`);
     if (crc32(data) !== buffer.readUInt32LE(offset + 14)) throw new Error(`ZIP CRC mismatch for ${name2}`);
@@ -4254,13 +4403,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);
     }
@@ -4269,7 +4417,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) {
@@ -4333,6 +4491,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);
 }
@@ -4405,7 +4597,11 @@ function validateBlock(value, path35, errors) {
         error(errors, `${path35}/text`, "TEXT_TOO_LARGE", "Text block is too large.");
         return void 0;
       }
-      const cacheControl = validateCacheControl(value["cache_control"], `${path35}/cache_control`, errors);
+      const cacheControl = validateCacheControl(
+        value["cache_control"],
+        `${path35}/cache_control`,
+        errors
+      );
       return cacheControl ? { type: "text", text: text2, cache_control: cacheControl } : { type: "text", text: text2 };
     }
     case "tool_use": {
@@ -4413,15 +4609,29 @@ function validateBlock(value, path35, errors) {
       const name2 = value["name"];
       const input = value["input"];
       if (typeof id !== "string" || id.length === 0) {
-        error(errors, `${path35}/id`, "INVALID_TOOL_USE_ID", "tool_use.id must be a non-empty string.");
+        error(
+          errors,
+          `${path35}/id`,
+          "INVALID_TOOL_USE_ID",
+          "tool_use.id must be a non-empty string."
+        );
       }
       if (typeof name2 !== "string" || name2.length === 0) {
-        error(errors, `${path35}/name`, "INVALID_TOOL_NAME", "tool_use.name must be a non-empty string.");
+        error(
+          errors,
+          `${path35}/name`,
+          "INVALID_TOOL_NAME",
+          "tool_use.name must be a non-empty string."
+        );
       }
       if (!isPlainJsonObject(input)) {
         error(errors, `${path35}/input`, "INVALID_TOOL_INPUT", "tool_use.input must be an object.");
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path35}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(
+        value["providerMeta"],
+        `${path35}/providerMeta`,
+        errors
+      );
       if (typeof id !== "string" || id.length === 0 || typeof name2 !== "string" || name2.length === 0 || !isPlainJsonObject(input)) {
         return void 0;
       }
@@ -4433,20 +4643,46 @@ function validateBlock(value, path35, errors) {
       const content = value["content"];
       const isError = value["is_error"];
       if (typeof toolUseId !== "string" || toolUseId.length === 0) {
-        error(errors, `${path35}/tool_use_id`, "INVALID_TOOL_RESULT_ID", "tool_result.tool_use_id must be a non-empty string.");
+        error(
+          errors,
+          `${path35}/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, `${path35}/name`, "INVALID_TOOL_RESULT_NAME", "tool_result.name must be a string.");
+        error(
+          errors,
+          `${path35}/name`,
+          "INVALID_TOOL_RESULT_NAME",
+          "tool_result.name must be a string."
+        );
       }
       if (typeof content !== "string") {
-        error(errors, `${path35}/content`, "INVALID_TOOL_RESULT_CONTENT", "tool_result.content must be a string.");
+        error(
+          errors,
+          `${path35}/content`,
+          "INVALID_TOOL_RESULT_CONTENT",
+          "tool_result.content must be a string."
+        );
       } else if (content.length > MAX_STRING_LENGTH) {
-        error(errors, `${path35}/content`, "TOOL_RESULT_TOO_LARGE", "tool_result.content is too large.");
+        error(
+          errors,
+          `${path35}/content`,
+          "TOOL_RESULT_TOO_LARGE",
+          "tool_result.content is too large."
+        );
       }
       if (isError !== void 0 && typeof isError !== "boolean") {
-        error(errors, `${path35}/is_error`, "INVALID_TOOL_RESULT_ERROR", "tool_result.is_error must be boolean.");
+        error(
+          errors,
+          `${path35}/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,
@@ -4463,28 +4699,92 @@ function validateBlock(value, path35, errors) {
       }
       const sourceType = source["type"];
       if (sourceType !== "base64" && sourceType !== "url") {
-        error(errors, `${path35}/source/type`, "INVALID_IMAGE_SOURCE_TYPE", "image.source.type must be base64 or url.");
+        error(
+          errors,
+          `${path35}/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, `${path35}/source/media_type`, "INVALID_IMAGE_MEDIA_TYPE", "image.source.media_type must be a string.");
+        error(
+          errors,
+          `${path35}/source/media_type`,
+          "INVALID_IMAGE_MEDIA_TYPE",
+          "image.source.media_type must be a string."
+        );
+        return void 0;
+      }
+      if (typeof mediaType === "string" && !isAllowedImageMediaType(mediaType)) {
+        error(
+          errors,
+          `${path35}/source/media_type`,
+          "UNSUPPORTED_IMAGE_MEDIA_TYPE",
+          `image.source.media_type must be one of: ${[...ALLOWED_IMAGE_MEDIA_TYPES].join(", ")}.`
+        );
+        return void 0;
       }
-      if (data !== void 0 && typeof data !== "string") {
-        error(errors, `${path35}/source/data`, "INVALID_IMAGE_DATA", "image.source.data must be a string.");
+      if (sourceType === "base64") {
+        if (typeof data !== "string" || data.length === 0) {
+          error(
+            errors,
+            `${path35}/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,
+            `${path35}/source/data`,
+            "INVALID_IMAGE_DATA",
+            "image.source.data is not valid base64."
+          );
+          return void 0;
+        }
+        if (base64DecodedBytes(data) > MAX_INCOMING_IMAGE_BYTES) {
+          error(
+            errors,
+            `${path35}/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 (typeof url !== "string" || url.length === 0) {
+        error(
+          errors,
+          `${path35}/source/url`,
+          "INVALID_IMAGE_URL",
+          "image.source.url must be a non-empty string for a url source."
+        );
+        return void 0;
       }
-      if (url !== void 0 && typeof url !== "string") {
-        error(errors, `${path35}/source/url`, "INVALID_IMAGE_URL", "image.source.url must be a string.");
+      const urlError = imageUrlRejectionReason(url);
+      if (urlError !== void 0) {
+        error(errors, `${path35}/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
         }
       };
     }
@@ -4492,13 +4792,27 @@ function validateBlock(value, path35, errors) {
       const thinking = value["thinking"];
       const signature = value["signature"];
       if (typeof thinking !== "string") {
-        error(errors, `${path35}/thinking`, "INVALID_THINKING", "thinking.thinking must be a string.");
+        error(
+          errors,
+          `${path35}/thinking`,
+          "INVALID_THINKING",
+          "thinking.thinking must be a string."
+        );
         return void 0;
       }
       if (signature !== void 0 && typeof signature !== "string") {
-        error(errors, `${path35}/signature`, "INVALID_THINKING_SIGNATURE", "thinking.signature must be a string.");
+        error(
+          errors,
+          `${path35}/signature`,
+          "INVALID_THINKING_SIGNATURE",
+          "thinking.signature must be a string."
+        );
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path35}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(
+        value["providerMeta"],
+        `${path35}/providerMeta`,
+        errors
+      );
       return {
         type: "thinking",
         thinking,
@@ -4507,7 +4821,12 @@ function validateBlock(value, path35, errors) {
       };
     }
     default:
-      error(errors, `${path35}/type`, "UNKNOWN_BLOCK_TYPE", `Unknown content block type: ${String(type)}`);
+      error(
+        errors,
+        `${path35}/type`,
+        "UNKNOWN_BLOCK_TYPE",
+        `Unknown content block type: ${String(type)}`
+      );
       return void 0;
   }
 }
@@ -4519,7 +4838,12 @@ 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.");
@@ -4532,7 +4856,12 @@ function validateContextEditorMessages(value, currentMessageCount = 0) {
     }
     const role = item["role"];
     if (!isMessageRole(role)) {
-      error(errors, `${path35}/role`, "INVALID_ROLE", "Message role must be user, assistant, or system.");
+      error(
+        errors,
+        `${path35}/role`,
+        "INVALID_ROLE",
+        "Message role must be user, assistant, or system."
+      );
       return;
     }
     const rawContent = item["content"];
@@ -4551,13 +4880,23 @@ function validateContextEditorMessages(value, currentMessageCount = 0) {
       });
       content = blocks;
     } else {
-      error(errors, `${path35}/content`, "INVALID_CONTENT", "Message content must be a string or content block array.");
+      error(
+        errors,
+        `${path35}/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, `${path35}/ts`, "INVALID_TIMESTAMP", "Message ts must be an ISO-like timestamp string.");
+        error(
+          errors,
+          `${path35}/ts`,
+          "INVALID_TIMESTAMP",
+          "Message ts must be an ISO-like timestamp string."
+        );
         return;
       }
     }
@@ -4567,7 +4906,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) {
@@ -4631,11 +4971,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 ?? [],
@@ -4680,7 +5022,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) {
@@ -4692,7 +5037,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);
@@ -4775,6 +5123,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;
@@ -4845,25 +5194,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";
@@ -4901,6 +5256,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) {
@@ -4941,10 +5300,17 @@ 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 * as net2 from "node:net";
+import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
 import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
 import {
   checkCodebaseIndexServerHealth,
+  ensureCodebaseIndexServer as ensureCodebaseIndexServer2,
   getIndexState,
   resolveProjectIndexDaemonAvailability,
   shutdownCodebaseIndexServer
@@ -4973,7 +5339,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";
@@ -5278,6 +5645,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
+    }
+  };
+}
 async function handleConnectionsServiceAction(ws, message, context) {
   if (message.type !== "connections.service_action") return false;
   const payload = message.payload;
@@ -5295,14 +5698,14 @@ async function handleConnectionsServiceAction(ws, message, context) {
     });
     return true;
   }
-  if (rawAction !== "shutdown") {
+  if (rawAction !== "shutdown" && rawAction !== "restart") {
     context.send(ws, {
       type: "connections.service_action_result",
       payload: {
         serviceId,
         action: rawAction,
         success: false,
-        message: `Unsupported action "${rawAction}" \u2014 only "shutdown" is currently supported`
+        message: `Unsupported action "${rawAction}" \u2014 only "shutdown" and "restart" are supported`
       }
     });
     return true;
@@ -5315,7 +5718,7 @@ async function handleConnectionsServiceAction(ws, message, context) {
         serviceId: "webui",
         action,
         success: false,
-        message: "Cannot shut down the WebUI transport itself"
+        message: action === "restart" ? "Cannot restart the WebUI transport itself" : "Cannot shut down the WebUI transport itself"
       }
     });
     return true;
@@ -5356,6 +5759,13 @@ async function executeServiceAction(serviceId, action, projectRoot, indexDir) {
       return killCodebaseIndexServer(projectRoot, indexDir, action);
     case "mailbox":
       return killMailboxServer(projectRoot, action);
+    case "governance":
+      return {
+        serviceId: "governance",
+        action,
+        success: false,
+        message: "Governance health is read-only; daemon shutdown requires a separate admin control capability."
+      };
     default:
       return {
         serviceId,
@@ -5397,11 +5807,24 @@ async function killKanbanServer(projectRoot, action) {
     const result = await connection.request("shutdown", {
       reason: `WebUI request: ${action}`
     });
+    if (!result.stopping) {
+      return {
+        serviceId: "kanban",
+        action,
+        success: false,
+        message: "Kanban IPC daemon shutdown failed (not confirmed)"
+      };
+    }
+    if (action === "restart") {
+      closeKanbanServerConnections();
+      const restartResult = await restartKanbanServer(projectRoot);
+      return restartResult;
+    }
     return {
       serviceId: "kanban",
       action,
-      success: result.stopping,
-      message: result.stopping ? `Kanban IPC daemon ${action} requested` : `Kanban IPC daemon ${action} failed (shutdown not confirmed)`
+      success: true,
+      message: "Kanban IPC daemon shutdown requested"
     };
   } catch (error2) {
     return {
@@ -5412,6 +5835,34 @@ async function killKanbanServer(projectRoot, action) {
     };
   }
 }
+async function restartKanbanServer(projectRoot) {
+  await waitForShutdown(() => isKanbanServerAvailable(projectRoot));
+  try {
+    const connection = await getKanbanServerConnection(projectRoot);
+    if (!connection) {
+      return {
+        serviceId: "kanban",
+        action: "restart",
+        success: false,
+        message: "Kanban IPC daemon failed to restart (no connection after re-init)"
+      };
+    }
+    await connection.request("ping", {}, { timeoutMs: 1e4 });
+    return {
+      serviceId: "kanban",
+      action: "restart",
+      success: true,
+      message: "Kanban IPC daemon restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "kanban",
+      action: "restart",
+      success: false,
+      message: `Kanban IPC daemon restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  }
+}
 async function killSageServer(projectRoot, action) {
   if (!isSageProjectServerAvailable()) {
     return {
@@ -5424,11 +5875,22 @@ async function killSageServer(projectRoot, action) {
   const connection = new SageProjectServerConnection(projectRoot);
   try {
     const result = await connection.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "sage",
+        action,
+        success: false,
+        message: `SAGE memory server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartSageServer(projectRoot);
+    }
     return {
       serviceId: "sage",
       action,
-      success: result.stopped,
-      message: result.stopped ? `SAGE memory server ${action} requested` : `SAGE memory server ${action} failed: ${result.reason ?? "unknown"}`
+      success: true,
+      message: "SAGE memory server shutdown requested"
     };
   } catch (error2) {
     return {
@@ -5441,16 +5903,56 @@ async function killSageServer(projectRoot, action) {
     connection.close();
   }
 }
+async function restartSageServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new SageProjectServerConnection(projectRoot);
+    try {
+      return await probe.status() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new SageProjectServerConnection(projectRoot);
+  try {
+    await verifyConn.call("ping", {}, { timeoutMs: 1e4, meta: { clientId: `sage-restart-${process.pid}` } });
+    return {
+      serviceId: "sage",
+      action: "restart",
+      success: true,
+      message: "SAGE memory server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "sage",
+      action: "restart",
+      success: false,
+      message: `SAGE memory server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
 async function killChronicleServer(projectRoot, action) {
   const options = resolveChronicleProjectServerOptions({ projectRoot });
   const client = new ChronicleProjectServerClient(options);
   try {
     const result = await client.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "chronicle",
+        action,
+        success: false,
+        message: `Chronicle telemetry server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartChronicleServer(projectRoot);
+    }
     return {
       serviceId: "chronicle",
       action,
-      success: result.stopped,
-      message: result.stopped ? `Chronicle telemetry server ${action} requested` : `Chronicle telemetry server ${action} failed: ${result.reason ?? "unknown"}`
+      success: true,
+      message: "Chronicle telemetry server shutdown requested"
     };
   } catch (error2) {
     return {
@@ -5463,6 +5965,39 @@ async function killChronicleServer(projectRoot, action) {
     client.close();
   }
 }
+async function restartChronicleServer(projectRoot) {
+  const options = resolveChronicleProjectServerOptions({ projectRoot });
+  const endpoint = new ChronicleProjectServerClient(options).endpoint;
+  await waitForShutdown(async () => isEndpointAlive(endpoint));
+  let access2;
+  try {
+    access2 = createChronicleProjectAccess2({ projectRoot });
+    await access2.call("ping", {}, { timeoutMs: 1e4 });
+    if (access2.mode !== "server") {
+      return {
+        serviceId: "chronicle",
+        action: "restart",
+        success: false,
+        message: `Chronicle telemetry server restarted but running in ${access2.mode} mode (expected server)`
+      };
+    }
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: true,
+      message: "Chronicle telemetry server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: false,
+      message: `Chronicle telemetry server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    await access2?.close();
+  }
+}
 async function killCodebaseIndexServer(projectRoot, indexDir, action) {
   try {
     const result = await shutdownCodebaseIndexServer(
@@ -5470,11 +6005,22 @@ async function killCodebaseIndexServer(projectRoot, indexDir, action) {
       indexDir,
       `websocket-request:${action}`
     );
+    if (!result.stopped) {
+      return {
+        serviceId: "codebase-index",
+        action,
+        success: false,
+        message: `Codebase index server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartCodebaseIndexServer(projectRoot, indexDir);
+    }
     return {
       serviceId: "codebase-index",
       action,
-      success: result.stopped,
-      message: result.stopped ? `Codebase index server ${action} requested` : `Codebase index server ${action} failed: ${result.reason ?? "unknown"}`
+      success: true,
+      message: "Codebase index server shutdown requested"
     };
   } catch (error2) {
     return {
@@ -5485,6 +6031,45 @@ async function killCodebaseIndexServer(projectRoot, indexDir, action) {
     };
   }
 }
+async function restartCodebaseIndexServer(projectRoot, indexDir) {
+  await waitForShutdown(async () => {
+    try {
+      await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+        timeoutMs: 1e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  try {
+    await ensureCodebaseIndexServer2({ projectRoot, indexDir });
+    const health = await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+      timeoutMs: 1e4
+    });
+    if (health.status === "unresponsive") {
+      return {
+        serviceId: "codebase-index",
+        action: "restart",
+        success: false,
+        message: "Codebase index server restarted but is unresponsive"
+      };
+    }
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: true,
+      message: "Codebase index server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: false,
+      message: `Codebase index server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  }
+}
 async function killMailboxServer(projectRoot, action) {
   if (!isMailboxProjectServerAvailable()) {
     return {
@@ -5499,11 +6084,22 @@ async function killMailboxServer(projectRoot, action) {
   );
   try {
     const result = await connection.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "mailbox",
+        action,
+        success: false,
+        message: `Mailbox IPC server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartMailboxServer(projectRoot);
+    }
     return {
       serviceId: "mailbox",
       action,
-      success: result.stopped,
-      message: result.stopped ? `Mailbox IPC server ${action} requested` : `Mailbox IPC server ${action} failed: ${result.reason ?? "unknown"}`
+      success: true,
+      message: "Mailbox IPC server shutdown requested"
     };
   } catch (error2) {
     return {
@@ -5516,6 +6112,77 @@ async function killMailboxServer(projectRoot, action) {
     connection.close();
   }
 }
+async function restartMailboxServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new MailboxProjectServerConnection(
+      resolveWstackPaths2({ projectRoot }).projectDir
+    );
+    try {
+      return await probe.probeStatus() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new MailboxProjectServerConnection(
+    resolveWstackPaths2({ projectRoot }).projectDir
+  );
+  try {
+    await verifyConn.call("ping", {}, { timeoutMs: 1e4 });
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: true,
+      message: "Mailbox IPC server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: false,
+      message: `Mailbox IPC server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
+var RESTART_POLL_INTERVAL_MS = 250;
+var RESTART_DEADLINE_MS = 3e3;
+function isEndpointAlive(endpoint) {
+  return new Promise((resolve16) => {
+    const sock = net2.createConnection(endpoint);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve16(false);
+    }, 500);
+    timer.unref?.();
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve16(true);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve16(false);
+    });
+  });
+}
+async function waitForShutdown(probe) {
+  if (!probe) {
+    await new Promise((resolve16) => setTimeout(resolve16, RESTART_POLL_INTERVAL_MS));
+    return;
+  }
+  const deadline = Date.now() + RESTART_DEADLINE_MS;
+  while (Date.now() < deadline) {
+    try {
+      const stillUp = await probe();
+      if (!stillUp) return;
+    } catch {
+      return;
+    }
+    await new Promise((resolve16) => setTimeout(resolve16, RESTART_POLL_INTERVAL_MS));
+  }
+}
 function failureService(id, label, required, mode, error2, latencyMs) {
   const message = error2 instanceof Error ? error2.message : String(error2);
   return {
@@ -5792,11 +6459,11 @@ async function handleGitDiff(ws, projectRoot, path35) {
   try {
     const git = makeGit(cwd);
     const { readFile: readFile13 } = await import("node:fs/promises");
-    const { join: join19 } = await import("node:path");
+    const { join: join18 } = await import("node:path");
     const oldText = await git(["show", `HEAD:${path35}`]);
     let newText = "";
     try {
-      const abs = cwd ? join19(cwd, path35) : path35;
+      const abs = cwd ? join18(cwd, path35) : path35;
       const buf = await readFile13(abs);
       if (buf.includes(0)) {
         reply2({ oldText: "", newText: "", binary: true });
@@ -5962,8 +6629,11 @@ var GoalWebSocketHandler = class {
     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) {
@@ -6998,92 +7668,17 @@ function clearAnalyticsBuffer() {
   EVENT_COUNTS.clear();
   CATEGORY_COUNTS.clear();
 }
-function getAnalyticsBuffer() {
-  return [...EVENT_BUFFER];
-}
-
-// src/server/http-server.ts
-import * as fs10 from "node:fs/promises";
-import * as http from "node:http";
-import * as path13 from "node:path";
-import * as v8 from "node:v8";
-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 } : {}
-    })
-  );
-}
+function getAnalyticsBuffer() {
+  return [...EVENT_BUFFER];
+}
+
+// src/server/http-server.ts
+import * as fs10 from "node:fs/promises";
+import * as http from "node:http";
+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/deadcode-handlers.ts
 import * as path10 from "node:path";
@@ -7235,7 +7830,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" });
@@ -7271,7 +7943,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) {
@@ -7306,7 +7978,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) {
@@ -7453,11 +8125,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((resolve16, 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;
@@ -7522,7 +8199,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) {
@@ -7575,7 +8252,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) {
@@ -7616,7 +8293,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) {
@@ -7685,7 +8362,7 @@ 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) }));
   }
 }
 
@@ -8116,11 +8793,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;
   }
@@ -8179,6 +8865,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,
@@ -8199,13 +8902,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 {
@@ -8267,7 +8970,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;
@@ -8309,6 +9012,16 @@ function createHttpServer(opts) {
   const port = opts.port ?? Number.parseInt(process.env["PORT"] ?? "3456", 10);
   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");
@@ -8323,6 +9036,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 ?? "");
@@ -8526,42 +9249,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" });
@@ -8643,7 +9330,7 @@ function createHttpServer(opts) {
           res.end(
             JSON.stringify({
               error: "TechStack store unavailable",
-              detail: error2 instanceof Error ? error2.message : String(error2)
+              detail: sanitizeApiError2(error2)
             })
           );
           return;
@@ -8690,6 +9377,30 @@ function createHttpServer(opts) {
         );
         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 = path13.join(distDir, "index.html");
@@ -8995,6 +9706,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,
@@ -9096,7 +9812,6 @@ async function handleIntrospectionRoute(ctx, ws, message) {
 }
 
 // src/server/kanban-dispatch.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   areDependenciesMet,
   getServerKanbanStore
@@ -9122,14 +9837,6 @@ function reply(ws, type, success, value) {
     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;
@@ -9168,45 +9875,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 } : {},
@@ -9215,69 +9916,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?.({
@@ -9288,55 +9960,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);
   }
 }
@@ -9490,7 +10139,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 } : {},
@@ -9727,7 +10376,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"
     )
@@ -10088,7 +10737,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;
@@ -10172,7 +10821,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");
@@ -10223,7 +10872,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");
@@ -10340,7 +10989,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}.`
@@ -10370,7 +11019,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."
@@ -10407,7 +11056,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;
@@ -10429,7 +11078,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}.`
@@ -10454,7 +11103,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)}` : ""}.`
@@ -10481,7 +11130,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;
@@ -11035,12 +11684,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
@@ -11060,6 +11711,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,
@@ -11074,7 +11734,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;
@@ -11113,7 +11773,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) {
@@ -11133,7 +11801,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) } });
   }
@@ -11650,7 +12326,7 @@ async function handleSageDelete(ws, msg, memoryStore) {
   }
   try {
     await Sage.deleteSage(id, reason, {
-      force: force ?? true,
+      force: force === true,
       neverInject: neverInject === true
     });
     send(ws, {
@@ -12276,7 +12952,7 @@ function openBrowser(url, platform = process.platform) {
 }
 
 // src/server/port-utils.ts
-import * as net from "node:net";
+import * as net3 from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
 var SURFACE_DEFAULT_PORTS = {
   webui: { http: 3456 },
@@ -12290,7 +12966,7 @@ function getSurfaceDefaultPorts(surface) {
 }
 function isPortFree(host, port) {
   return new Promise((resolve16) => {
-    const srv = net.createServer();
+    const srv = net3.createServer();
     srv.once("error", () => resolve16(false));
     srv.once("listening", () => {
       srv.close(() => resolve16(true));
@@ -12419,7 +13095,8 @@ async function startStaticServe(opts, deps2 = {}) {
     projectRoot: opts.projectRoot,
     publicWsUrl: opts.publicWsUrl,
     apiToken: opts.apiToken,
-    requireToken: opts.requireToken
+    requireToken: opts.requireToken,
+    allowedHostnames: opts.allowedHostnames
   });
   if (!opts.deferListen) {
     server.listen(opts.httpPort, opts.host);
@@ -12753,6 +13430,7 @@ function createWebuiClientPresence(deps2) {
   let heartbeatTimer = null;
   let stopTelemetry;
   let hqConnection;
+  let closed = false;
   const register = async () => {
     if (!deps2.projectRoot) return null;
     try {
@@ -12792,6 +13470,7 @@ function createWebuiClientPresence(deps2) {
         }
       });
       clientId = `webui@${crypto2.randomUUID().slice(0, 8)}`;
+      closed = false;
       await nextMailbox.registerClient({
         clientId,
         sessionId: deps2.getSessionId(),
@@ -12799,6 +13478,10 @@ function createWebuiClientPresence(deps2) {
         source: "webui",
         pid: process.pid
       });
+      if (closed) {
+        nextMailbox.deregisterClient(clientId).catch(() => void 0);
+        return null;
+      }
       heartbeatTimer = setInterval(() => {
         nextMailbox.clientHeartbeat({ clientId, sessionId: deps2.getSessionId() }).catch(() => void 0);
       }, CLIENT_HEARTBEAT_MS);
@@ -12809,6 +13492,7 @@ function createWebuiClientPresence(deps2) {
     }
   };
   const unregister = () => {
+    closed = true;
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     heartbeatTimer = null;
     stopTelemetry?.();
@@ -13682,6 +14366,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;
@@ -13718,7 +14403,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;
@@ -13764,7 +14449,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 = [];
     }
@@ -13908,7 +14596,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];
@@ -13923,7 +14632,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")
@@ -14219,14 +14928,14 @@ import { createCompatibilityTrustBoundary } from "@wrongstack/core/security";
 import { getProcessRegistry as getProcessRegistry2 } from "@wrongstack/tools";
 
 // src/server/privileged-actions.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   isTrustDecisionAllowed
 } from "@wrongstack/core/security";
 async function authorizeWebUIAction(boundary, action, logger) {
   const request = {
     version: 1,
-    requestId: randomUUID5(),
+    requestId: randomUUID4(),
     actor: {
       kind: "remote-client",
       ...action.sessionId ? { sessionId: action.sessionId } : {}
@@ -14593,7 +15302,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
@@ -14865,7 +15574,7 @@ function projectSavedProviders(providers) {
     return view;
   });
 }
-var probeScrubber = new DefaultSecretScrubber();
+var probeScrubber = new DefaultSecretScrubber2();
 async function probeModelDescriptors(cfg) {
   if (!cfg.baseUrl) return [];
   try {
@@ -18552,6 +19261,7 @@ var SddBoardWebSocketHandler = class {
   poll = null;
   pollInFlight = false;
   unsub = null;
+  disposed = false;
   constructor(boardsDir, events, lifecycle, security) {
     this.store = new SddBoardStore({ baseDir: boardsDir });
     this.lifecycle = lifecycle;
@@ -18566,6 +19276,7 @@ var SddBoardWebSocketHandler = class {
     }
   }
   addClient(ws) {
+    if (this.disposed) return;
     const client = { ws, id: crypto.randomUUID() };
     this.clients.add(client);
     const remove = () => {
@@ -18707,9 +19418,12 @@ var SddBoardWebSocketHandler = class {
     }
   }
   dispose() {
+    this.disposed = true;
     this.stopPolling();
     this.unsub?.();
     this.unsub = null;
+    this.clients.clear();
+    this.latest = null;
   }
   // ── internal ────────────────────────────────────────────────────────────
   async pollLatest() {
@@ -18717,6 +19431,7 @@ var SddBoardWebSocketHandler = class {
     this.pollInFlight = true;
     try {
       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;
@@ -19030,6 +19745,7 @@ var SddWizardWebSocketHandler = class {
    * flight (or after the probe has settled).
    */
   resumeProbe = null;
+  disposed = false;
   async bootstrap() {
     try {
       await this.deps.ensureReady?.();
@@ -19042,23 +19758,28 @@ var SddWizardWebSocketHandler = class {
     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() ?? "";
       }
       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;
@@ -19071,7 +19792,16 @@ 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) {
@@ -19289,6 +20019,7 @@ var SddWizardWebSocketHandler = class {
     this.broadcast(this.snapshotMsg());
     try {
       const text2 = await this.deps.runInterviewTurn(prompt);
+      if (this.disposed) return;
       this.lastAgentText = text2;
       if (this.driver) {
         await this.driver.ingestAgentOutput(text2);
@@ -19314,6 +20045,7 @@ var SddWizardWebSocketHandler = class {
     }
   }
   send(client, msg) {
+    if (!this.clients.has(client)) return;
     sendSerialized(client.ws, JSON.stringify(msg));
   }
 };
@@ -20080,6 +20812,7 @@ function setupEvents(deps2) {
     });
     pendingConfirms.set(id, {
       resolve: e.resolve,
+      sessionId: e.sessionId,
       decisionSource: e.decisionSource,
       riskTier: e.riskTier,
       boundaryReason: e.boundaryReason,
@@ -20608,6 +21341,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":
@@ -20743,12 +21479,13 @@ 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 randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import * as http2 from "node:http";
 import * as path34 from "node:path";
 import { createDefaultPipelines } from "@wrongstack/core/agent";
@@ -20773,7 +21510,7 @@ import { toLanguagePackageInput } from "@wrongstack/techstack";
 import { ensureSessionShell } from "@wrongstack/tools";
 
 // src/server/backend-services.ts
-import { join as join16 } from "node:path";
+import { join as join15 } from "node:path";
 import { Agent } from "@wrongstack/core/agent";
 import {
   BrainDecisionLedger,
@@ -20786,7 +21523,7 @@ import {
   mailboxSessionTag,
   ObservableBrainArbiter as ObservableBrainArbiterCtor
 } from "@wrongstack/core/coordination";
-import { DEFAULT_TOOLS_CONFIG } from "@wrongstack/core/defaults";
+import { DEFAULT_TOOLS_CONFIG } from "@wrongstack/core/types";
 import { installDesignStudioMiddleware } from "@wrongstack/core/design";
 import {
   AutoCompactionMiddleware as AutoCompactionMiddlewareCtor,
@@ -20816,7 +21553,7 @@ import {
 import { spawn as spawn4 } from "node:child_process";
 import { createRequire } from "node:module";
 import { existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname10, join as join14 } from "node:path";
+import { dirname as dirname10, join as join13 } from "node:path";
 import { resolveProjectDir as resolveProjectDir3 } from "@wrongstack/core/coordination";
 import { wstackGlobalRoot as wstackGlobalRoot3 } from "@wrongstack/core/utils";
 import { readLiveLock } from "@wrongstack/core/coordination";
@@ -20945,7 +21682,7 @@ function mailboxServeInvocation(projectRoot) {
 function findWorkspaceCliEntry(projectRoot) {
   let dir = projectRoot;
   for (let i = 0; i < 6; i++) {
-    const candidate = join14(dir, "packages", "cli", "dist", "index.js");
+    const candidate = join13(dir, "packages", "cli", "dist", "index.js");
     if (existsSync2(candidate)) return candidate;
     const parent = dirname10(dir);
     if (parent === dir) return null;
@@ -21190,7 +21927,7 @@ function clampDim(value, fallback) {
 }
 
 // src/server/worktree-ws-handler.ts
-import { join as join15, resolve as resolve13, sep as sep5 } from "node:path";
+import { join as join14, resolve as resolve13, sep as sep5 } from "node:path";
 import { toErrorMessage as toErrorMessage9 } from "@wrongstack/core/utils";
 import { WorktreeManager as WorktreeManager3 } from "@wrongstack/core/worktree";
 import { cleanupStaleSddWorktrees as cleanupStaleSddWorktrees2 } from "@wrongstack/sdd";
@@ -21267,11 +22004,15 @@ 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. */
   worktreesRoot() {
-    return resolve13(join15(this.management.projectRoot, ".wrongstack", "worktrees"));
+    return resolve13(join14(this.management.projectRoot, ".wrongstack", "worktrees"));
   }
   /** True iff `dir` resolves strictly inside the managed worktrees root. */
   underRoot(dir) {
@@ -21664,7 +22405,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
         })
       );
     }
@@ -21788,6 +22535,7 @@ async function createAgentServices(input) {
     perIterationOutputCapBytes: config.tools?.perIterationOutputCapBytes ?? DEFAULT_TOOLS_CONFIG.perIterationOutputCapBytes,
     tracer: void 0
   });
+  input.installToolBoundary?.(pipelines);
   const webuiLogger = container.resolve(TOKENS2.Logger);
   void discoverMailboxBridgeForWebui({
     projectRoot,
@@ -21827,7 +22575,7 @@ async function createAgentServices(input) {
   const brainCfg = resolveBrainConfigDefaults(config.brain, {
     fallbackModels: config.fallbackModels
   });
-  const brainLedgerPath = join16(wpaths.projectDir, "brain-ledger.jsonl");
+  const brainLedgerPath = join15(wpaths.projectDir, "brain-ledger.jsonl");
   let brainLedgerEnabled = brainCfg.ledger?.enabled !== false;
   let brainLedger;
   const startBrainLedger = () => {
@@ -22000,7 +22748,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(TOKENS2.ProviderModelStatusTracker)
+        statusTracker: container.safeResolve(TOKENS2.ProviderModelStatusTracker),
+        ...input.installToolBoundary ? { installToolBoundary: input.installToolBoundary } : {}
       }),
       paths: {
         projectSpecs: wpaths.projectSpecs,
@@ -22039,6 +22788,8 @@ async function createAgentServices(input) {
     for (const off of brainLogOffs) off();
     goalHandler.dispose();
     sddBoardHandler.dispose();
+    sddWizardHandler.dispose();
+    specsHandler.dispose();
     worktreeHandler.dispose();
     terminalHandler.dispose();
     collabHandler.dispose();
@@ -22074,7 +22825,10 @@ async function createAgentServices(input) {
 }
 
 // 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;
@@ -22154,6 +22908,72 @@ 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 path28 from "node:path";
 function createMessageDispatcher(opts) {
@@ -23858,6 +24678,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,
@@ -23880,6 +24711,7 @@ async function startWebUI(opts = {}) {
     skillInstaller,
     tokenCounter,
     pipelines: createDefaultPipelines(),
+    ...installToolBoundary ? { installToolBoundary } : {},
     modelCapabilitiesRef,
     sessionGetter: () => session,
     sessionReader,
@@ -23961,7 +24793,7 @@ async function startWebUI(opts = {}) {
       const input = toLanguagePackageInput(operation, workspace);
       const use = {
         type: "tool_use",
-        id: `techstack-remediation-${randomUUID6()}`,
+        id: `techstack-remediation-${randomUUID5()}`,
         name: "language_package",
         input: { ...input }
       };
@@ -24230,7 +25062,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({
@@ -24238,6 +25071,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 } : {},
@@ -24372,6 +25206,12 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
       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(() => {
       });