@wrongstack/webui-server 0.298.3 → 0.300.0

package/dist/index.js

@@ -73,6 +73,10 @@ var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   // Display-only toggles (purely visual, persisted in localStorage via Zustand).
   "groupToolCalls",
   "showThinkingLogs",
+  // v15: auto-collapse of the chat input under the history (opt-in display
+  // toggle, default off). Whitelisted so the key survives `prefs.update`
+  // round-trips without tripping the "unknown preference key" rejection.
+  "autoCollapseInput",
   // v11 Display parity: inverse fsAccess flag.
   "allowOutsideProjectRoot",
   // v13 Display parity (TUI SettingsPicker fields 42 & 43): the read tool
@@ -397,6 +401,51 @@ function validateModelSwitchPayload(payload) {
     }
   };
 }
+function validateModelFallbackChoicePayload(payload) {
+  if (!isRecord2(payload)) {
+    return {
+      ok: false,
+      message: "model.fallback_choice payload must be an object"
+    };
+  }
+  const requestId = payload["requestId"];
+  if (typeof requestId !== "string" || requestId.trim().length === 0) {
+    return {
+      ok: false,
+      message: "model.fallback_choice payload.requestId must be a non-empty string"
+    };
+  }
+  const providerId = payload["providerId"];
+  const model = payload["model"];
+  const autoSwitch = payload["autoSwitch"];
+  if (providerId !== void 0 && typeof providerId !== "string") {
+    return {
+      ok: false,
+      message: "model.fallback_choice payload.providerId must be a string when provided"
+    };
+  }
+  if (model !== void 0 && typeof model !== "string") {
+    return {
+      ok: false,
+      message: "model.fallback_choice payload.model must be a string when provided"
+    };
+  }
+  if (autoSwitch !== void 0 && typeof autoSwitch !== "boolean") {
+    return {
+      ok: false,
+      message: "model.fallback_choice payload.autoSwitch must be a boolean when provided"
+    };
+  }
+  return {
+    ok: true,
+    value: {
+      requestId: requestId.trim(),
+      ...typeof providerId === "string" ? { providerId } : {},
+      ...typeof model === "string" ? { model } : {},
+      ...typeof autoSwitch === "boolean" ? { autoSwitch } : {}
+    }
+  };
+}
 var AUTONOMY_VALUES2 = /* @__PURE__ */ new Set(["off", "suggest", "auto", "eternal", "eternal-parallel"]);
 function validateMailboxMessagesPayload(payload) {
   if (payload === void 0) return { ok: true, value: void 0 };
@@ -4417,13 +4466,10 @@ function createConversationOperations(ctx) {
 
 // src/server/context-editor.ts
 import { createHash } from "node:crypto";
-import net from "node:net";
 import {
   ALLOWED_IMAGE_MEDIA_TYPES,
   base64DecodedBytes,
   isAllowedImageMediaType,
-  isPrivateIPv4,
-  isPrivateIPv6,
   isValidImageBase64,
   MAX_INCOMING_IMAGE_BYTES,
   repairToolUseAdjacency
@@ -4491,40 +4537,7 @@ 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;
-}
+var MAX_REMOVAL_COUNT = 4096;
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -4533,7 +4546,7 @@ function canonicalize(value) {
   if (isRecord3(value)) {
     const sorted = {};
     for (const key of Object.keys(value).sort()) {
-      if (key === "_estTokens") continue;
+      if (key === "_estTokens" || key === "_toolErrorInfo") continue;
       const item = value[key];
       if (item === void 0) continue;
       sorted[key] = canonicalize(item);
@@ -4564,6 +4577,12 @@ function isMessageRole(value) {
 function isPlainJsonObject(value) {
   return isRecord3(value);
 }
+function splitsSurrogatePair(text2, offset) {
+  if (offset <= 0 || offset >= text2.length) return false;
+  const previous = text2.charCodeAt(offset - 1);
+  const next = text2.charCodeAt(offset);
+  return previous >= 55296 && previous <= 56319 && next >= 56320 && next <= 57343;
+}
 function validateCacheControl(value, path35, errors) {
   if (value === void 0) return void 0;
   if (!isRecord3(value) || value["type"] !== "ephemeral") {
@@ -4774,19 +4793,13 @@ function validateBlock(value, path35, errors) {
         );
         return void 0;
       }
-      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: "url",
-          ...typeof mediaType === "string" ? { media_type: mediaType } : {},
-          url
-        }
-      };
+      error(
+        errors,
+        `${path35}/source/url`,
+        "UNSAFE_IMAGE_URL",
+        "URL image sources are not allowed in context editor proposals; use an ingested base64 image."
+      );
+      return void 0;
     }
     case "thinking": {
       const thinking = value["thinking"];
@@ -4943,6 +4956,14 @@ function warningsForMessage(message, index) {
         message: "This block contains provider replay metadata and should only be removed with the whole turn if no longer needed."
       });
     }
+    if (block.type === "image" && block.source.type === "url") {
+      warnings.push({
+        path: `/messages/${index}/content/${blockIndex}/source/url`,
+        code: "UNSAFE_IMAGE_URL",
+        severity: "danger",
+        message: "URL image sources cannot be retained in context editor proposals; remove the whole message before applying other edits."
+      });
+    }
     if (block.type === "tool_result" && block.content.length > 2e4) {
       warnings.push({
         path: `/messages/${index}/content/${blockIndex}`,
@@ -4970,6 +4991,21 @@ function metricFor(ctx, messages, tools) {
     fullRequestTokens: breakdown.total
   };
 }
+function isToolResultMessage(message) {
+  return Boolean(
+    message?.role === "user" && Array.isArray(message.content) && message.content.length > 0 && message.content.every((block) => block.type === "tool_result")
+  );
+}
+function pairedAssistantIndices(messages, userIndex) {
+  if (messages[userIndex]?.role !== "user" || isToolResultMessage(messages[userIndex])) return [];
+  const paired = [];
+  for (let index = userIndex + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.role === "user" && !isToolResultMessage(message)) break;
+    if (message?.role === "assistant") paired.push(index);
+  }
+  return paired;
+}
 function buildContextEditorSnapshot(ctx, tools) {
   const messages = ctx.messages.map(
     (message) => ({
@@ -4999,11 +5035,165 @@ function buildContextEditorSnapshot(ctx, tools) {
       tokens: messageTokens(message.content),
       preview: breakdown.messages.breakdown[index]?.preview ?? "",
       blockCount: Array.isArray(message.content) ? message.content.length : null,
-      warnings: warningsForMessage(message, index)
+      warnings: warningsForMessage(message, index),
+      pairedAssistantIndices: pairedAssistantIndices(ctx.messages, index)
     })),
     diagnostics: toolDiagnostics(ctx.messages)
   };
 }
+function validateRemovalPlan(value, originalMessages, proposedMessages) {
+  const errors = [];
+  if (value === void 0) {
+    error(
+      errors,
+      "/removals",
+      "REMOVAL_PLAN_REQUIRED",
+      "A removal plan is required for every context editor proposal."
+    );
+    return { errors };
+  }
+  if (!Array.isArray(value)) {
+    error(errors, "/removals", "INVALID_REMOVALS", "removals must be an array.");
+    return { errors };
+  }
+  if (value.length > MAX_REMOVAL_COUNT) {
+    error(
+      errors,
+      "/removals",
+      "TOO_MANY_REMOVALS",
+      `removals must contain at most ${MAX_REMOVAL_COUNT} entries.`
+    );
+    return { errors };
+  }
+  const wholeMessages = /* @__PURE__ */ new Set();
+  const touchedUsers = /* @__PURE__ */ new Set();
+  const ranges = [];
+  for (const [removalIndex, raw] of value.entries()) {
+    const path35 = `/removals/${removalIndex}`;
+    if (!isRecord3(raw) || !Number.isInteger(raw["messageIndex"])) {
+      error(errors, path35, "INVALID_REMOVAL", "Removal must include an integer messageIndex.");
+      continue;
+    }
+    const messageIndex = raw["messageIndex"];
+    const original = originalMessages[messageIndex];
+    if (!original) {
+      error(errors, `${path35}/messageIndex`, "INVALID_MESSAGE_INDEX", "Removal messageIndex is out of range.");
+      continue;
+    }
+    const start = raw["start"];
+    const end = raw["end"];
+    const blockIndex = raw["blockIndex"];
+    if (start === void 0 && end === void 0 && blockIndex === void 0) {
+      wholeMessages.add(messageIndex);
+      if (original.role === "user") touchedUsers.add(messageIndex);
+      continue;
+    }
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start) {
+      error(errors, path35, "INVALID_RANGE", "Range removal requires integer start/end with 0 <= start < end.");
+      continue;
+    }
+    let text2;
+    if (blockIndex === void 0 && typeof original.content === "string") text2 = original.content;
+    if (Number.isInteger(blockIndex) && Array.isArray(original.content)) {
+      const block = original.content[blockIndex];
+      if (block?.type === "text") text2 = block.text;
+    }
+    if (text2 === void 0 || end > text2.length) {
+      error(errors, path35, "INVALID_RANGE_TARGET", "Range must target existing string or text-block content.");
+      continue;
+    }
+    if (splitsSurrogatePair(text2, start) || splitsSurrogatePair(text2, end)) {
+      error(
+        errors,
+        path35,
+        "INVALID_UNICODE_RANGE",
+        "Range boundaries must not split a Unicode surrogate pair."
+      );
+      continue;
+    }
+    ranges.push({
+      messageIndex,
+      ...blockIndex === void 0 ? {} : { blockIndex },
+      start,
+      end
+    });
+    if (original.role === "user") touchedUsers.add(messageIndex);
+  }
+  const rangesByTarget = /* @__PURE__ */ new Map();
+  for (const range of ranges) {
+    const key = `${range.messageIndex}:${range.blockIndex ?? "string"}`;
+    const targetRanges = rangesByTarget.get(key) ?? [];
+    targetRanges.push(range);
+    rangesByTarget.set(key, targetRanges);
+  }
+  for (const targetRanges of rangesByTarget.values()) {
+    targetRanges.sort((left, right) => (left.start ?? 0) - (right.start ?? 0));
+    for (let index = 1; index < targetRanges.length; index += 1) {
+      const previous = targetRanges[index - 1];
+      const current2 = targetRanges[index];
+      if (previous?.end !== void 0 && current2?.start !== void 0 && current2.start < previous.end) {
+        error(
+          errors,
+          "/removals",
+          "OVERLAPPING_RANGES",
+          "Removal ranges targeting the same text must not overlap."
+        );
+        break;
+      }
+    }
+  }
+  for (const userIndex of touchedUsers) {
+    for (const assistantIndex of pairedAssistantIndices(originalMessages, userIndex)) {
+      if (wholeMessages.has(assistantIndex)) continue;
+      error(
+        errors,
+        "/removals",
+        "MISSING_ASSISTANT_PAIR",
+        `Editing user message ${userIndex} must also remove assistant message ${assistantIndex}.`
+      );
+    }
+  }
+  const expectedMessages = structuredClone(originalMessages);
+  for (const targetRanges of rangesByTarget.values()) {
+    const first = targetRanges[0];
+    if (!first) continue;
+    const message = expectedMessages[first.messageIndex];
+    if (!message) continue;
+    let text2;
+    if (first.blockIndex === void 0 && typeof message.content === "string") {
+      text2 = message.content;
+    } else if (first.blockIndex !== void 0 && Array.isArray(message.content)) {
+      const block = message.content[first.blockIndex];
+      if (block?.type === "text") text2 = block.text;
+    }
+    if (text2 === void 0) continue;
+    const pieces = [];
+    let cursor = 0;
+    for (const range of targetRanges) {
+      if (range.start === void 0 || range.end === void 0) continue;
+      pieces.push(text2.slice(cursor, range.start));
+      cursor = range.end;
+    }
+    pieces.push(text2.slice(cursor));
+    const nextText = pieces.join("");
+    if (first.blockIndex === void 0 && typeof message.content === "string") {
+      message.content = nextText;
+    } else if (first.blockIndex !== void 0 && Array.isArray(message.content)) {
+      const block = message.content[first.blockIndex];
+      if (block?.type === "text") block.text = nextText;
+    }
+  }
+  const expectedProposal = expectedMessages.filter((_, index) => !wholeMessages.has(index));
+  if (JSON.stringify(canonicalize(expectedProposal)) !== JSON.stringify(canonicalize(proposedMessages))) {
+    error(
+      errors,
+      "/messages",
+      "REMOVAL_PLAN_MISMATCH",
+      "Submitted messages do not exactly match the declared removal plan."
+    );
+  }
+  return errors.length > 0 ? { errors } : { errors, messages: expectedProposal };
+}
 function validateContextEditorProposal(input) {
   const currentRevision = contextEditorRevision(input.ctx.messages);
   const before = metricFor(input.ctx, input.ctx.messages, input.tools);
@@ -5055,7 +5245,23 @@ function validateContextEditorProposal(input) {
       repair: emptyRepair
     };
   }
-  const repaired = repairToolUseAdjacency(parsed.messages);
+  const removalPlan = validateRemovalPlan(
+    input.removals,
+    input.ctx.messages,
+    parsed.messages
+  );
+  if (removalPlan.errors.length > 0 || !removalPlan.messages) {
+    return {
+      ok: false,
+      baseRevision: input.baseRevision,
+      currentRevision,
+      before,
+      validationErrors: removalPlan.errors,
+      warnings: [],
+      repair: emptyRepair
+    };
+  }
+  const repaired = repairToolUseAdjacency(removalPlan.messages);
   const repair = {
     changed: repaired.report.changed,
     removedToolUses: repaired.report.removedToolUses,
@@ -5305,7 +5511,7 @@ import {
   getKanbanServerConnection,
   isKanbanServerAvailable
 } from "@wrongstack/kanban";
-import * as net2 from "node:net";
+import * as net from "node:net";
 import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
 import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
 import {
@@ -6149,7 +6355,7 @@ var RESTART_POLL_INTERVAL_MS = 250;
 var RESTART_DEADLINE_MS = 3e3;
 function isEndpointAlive(endpoint) {
   return new Promise((resolve16) => {
-    const sock = net2.createConnection(endpoint);
+    const sock = net.createConnection(endpoint);
     const timer = setTimeout(() => {
       sock.destroy();
       resolve16(false);
@@ -8094,7 +8300,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
   }
   try {
     const { SessionRegistry, DefaultSessionStore: DefaultSessionStore4, DefaultSessionReader: DefaultSessionReader2 } = await import("@wrongstack/core/storage");
-    const { resolveWstackPaths: resolveWstackPaths6 } = await import("@wrongstack/core/utils");
+    const { resolveWstackPaths: resolveWstackPaths7 } = await import("@wrongstack/core/utils");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -8102,7 +8308,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths6({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths7({ projectRoot: entry.projectRoot, globalRoot });
     const store = new DefaultSessionStore4({ dir: paths.projectSessions });
     const reader = new DefaultSessionReader2({ store });
     const rawEntries = [];
@@ -8183,7 +8389,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox6, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core/coordination");
-    const { resolveWstackPaths: resolveWstackPaths6 } = await import("@wrongstack/core/utils");
+    const { resolveWstackPaths: resolveWstackPaths7 } = await import("@wrongstack/core/utils");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -8191,7 +8397,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths6({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths7({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = getSharedProjectMailbox6(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.send({ from, to, type, subject, body: text2, priority });
@@ -8211,7 +8417,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox6, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core/coordination");
-    const { resolveWstackPaths: resolveWstackPaths6 } = await import("@wrongstack/core/utils");
+    const { resolveWstackPaths: resolveWstackPaths7 } = await import("@wrongstack/core/utils");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -8219,7 +8425,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths6({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths7({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = getSharedProjectMailbox6(paths.projectDir);
     const leaderAddr = `leader@${mailboxSessionTag2(sessionId)}`;
     const [inbound, outbound] = await Promise.all([
@@ -8271,7 +8477,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox6, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core/coordination");
-    const { resolveWstackPaths: resolveWstackPaths6 } = await import("@wrongstack/core/utils");
+    const { resolveWstackPaths: resolveWstackPaths7 } = await import("@wrongstack/core/utils");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -8279,7 +8485,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths6({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths7({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = getSharedProjectMailbox6(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.sendRuntimeControl({
@@ -8320,7 +8526,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox6, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core/coordination");
-    const { resolveWstackPaths: resolveWstackPaths6 } = await import("@wrongstack/core/utils");
+    const { resolveWstackPaths: resolveWstackPaths7 } = await import("@wrongstack/core/utils");
     const registry = new SessionRegistry(globalRoot);
     const all = await registry.list();
     const mySlug = all.find((s) => s.pid === process.pid)?.projectSlug;
@@ -8332,7 +8538,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
     }
     const mbByDir = /* @__PURE__ */ new Map();
     const mailboxFor = (projectRoot) => {
-      const dir = resolveWstackPaths6({ projectRoot, globalRoot }).projectDir;
+      const dir = resolveWstackPaths7({ projectRoot, globalRoot }).projectDir;
       let mb = mbByDir.get(dir);
       if (!mb) {
         mb = getSharedProjectMailbox6(dir);
@@ -8366,6 +8572,246 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
   }
 }
 
+// src/server/requirement-intake-handlers.ts
+import { readProjectIdentity } from "@wrongstack/core/utils";
+import {
+  IntakeError,
+  IntakeValidationError
+} from "@wrongstack/requirement-intake";
+var SERVER_ACTOR = { id: "webui-server", type: "agent" };
+var MAX_INTAKE_BODY_BYTES = 512e3;
+function intakeContext(projectId) {
+  return { ...SERVER_ACTOR, projectId };
+}
+function sendJson2(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function sendNotFound(res, intakeId) {
+  sendJson2(res, 404, {
+    error: {
+      code: "INTAKE_NOT_FOUND",
+      message: `Requirement intake record not found: ${intakeId}`
+    }
+  });
+}
+function sendIntakeError(res, error2) {
+  if (error2 instanceof IntakeValidationError) {
+    sendJson2(res, 400, {
+      error: { code: error2.code, message: error2.message, issues: error2.issues }
+    });
+    return;
+  }
+  if (error2 instanceof IntakeError) {
+    const status = error2.code === "INTAKE_UNAUTHORIZED" ? 403 : error2.code === "INTAKE_NOT_FOUND" ? 404 : error2.code === "INTAKE_SUGGESTION_ERROR" ? 502 : 409;
+    sendJson2(res, status, { error: { code: error2.code, message: error2.message } });
+    return;
+  }
+  sendJson2(res, 500, { error: { code: "INTERNAL_ERROR", message: "Internal server error" } });
+}
+function serviceOr503(res, service) {
+  if (service) return true;
+  sendJson2(res, 503, {
+    error: { code: "INTAKE_UNAVAILABLE", message: "Requirement intake service not configured" }
+  });
+  return false;
+}
+async function readJsonBody3(res, req) {
+  const contentType = (req.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") {
+    sendJson2(res, 400, {
+      error: {
+        code: "INVALID_CONTENT_TYPE",
+        message: `Unsupported Content-Type: ${contentType || "(absent)"}`
+      }
+    });
+    return null;
+  }
+  return new Promise((resolve16) => {
+    let data = "";
+    let failed = false;
+    const fail2 = (message) => {
+      if (failed) return;
+      failed = true;
+      sendJson2(res, 400, { error: { code: "INVALID_BODY", message } });
+      resolve16(null);
+    };
+    req.on("data", (chunk) => {
+      if (failed) return;
+      data += chunk.toString("utf8");
+      if (data.length > MAX_INTAKE_BODY_BYTES) {
+        req.destroy();
+        fail2("Request body too large");
+      }
+    });
+    req.on("end", () => {
+      if (failed) return;
+      try {
+        resolve16(data.trim().length === 0 ? {} : JSON.parse(data));
+      } catch {
+        fail2("Request body is not valid JSON");
+      }
+    });
+    req.on("error", () => fail2("Failed to read request body"));
+  });
+}
+async function discoverIntake(res, service, intakeId) {
+  const record2 = await service.getIntake(intakeId, intakeContext(""));
+  if (!record2) {
+    sendNotFound(res, intakeId);
+    return null;
+  }
+  return record2;
+}
+async function handleRequirementIntakeListForServer(res, service, projectRoot) {
+  if (!serviceOr503(res, service)) return;
+  if (!projectRoot) {
+    sendJson2(res, 503, {
+      error: { code: "PROJECT_ROOT_NOT_CONFIGURED", message: "Project root not configured" }
+    });
+    return;
+  }
+  try {
+    const identity = await readProjectIdentity(projectRoot);
+    if (!identity) {
+      sendJson2(res, 404, {
+        error: {
+          code: "PROJECT_IDENTITY_NOT_FOUND",
+          message: "No project identity found \u2014 run `wstack init` first"
+        }
+      });
+      return;
+    }
+    const projectId = identity.projectId;
+    const records = await service.listIntakes(projectId, intakeContext(projectId));
+    sendJson2(res, 200, { projectId, intakes: records });
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeCreate(res, req, service, projectId) {
+  if (!serviceOr503(res, service)) return;
+  const body = await readJsonBody3(res, req);
+  if (body === null) return;
+  try {
+    const result = await service.createIntake(body, intakeContext(projectId));
+    sendJson2(res, result.idempotent ? 200 : 201, result);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeList(res, service, projectId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const records = await service.listIntakes(projectId, intakeContext(projectId));
+    sendJson2(res, 200, records);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeGet(res, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    sendJson2(res, 200, record2);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeUpdate(res, req, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  const body = await readJsonBody3(res, req);
+  if (body === null) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const expectedVersion = typeof body["expectedVersion"] === "number" ? body["expectedVersion"] : void 0;
+    const { expectedVersion: _ignored, ...patch } = body;
+    void _ignored;
+    const updated = await service.updateIntake(
+      intakeId,
+      patch,
+      intakeContext(record2.projectId),
+      expectedVersion
+    );
+    sendJson2(res, 200, updated);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeAnswers(res, req, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  const body = await readJsonBody3(res, req);
+  if (body === null) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const updated = await service.addAnswer(
+      intakeId,
+      body,
+      intakeContext(record2.projectId)
+    );
+    sendJson2(res, 200, updated);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeSuggestions(res, req, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  const body = await readJsonBody3(res, req);
+  if (body === null) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const focus = Array.isArray(body["focus"]) ? body["focus"] : void 0;
+    const suggestions = await service.generateSuggestions(
+      intakeId,
+      intakeContext(record2.projectId),
+      focus
+    );
+    sendJson2(res, 200, { suggestions });
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeSubmit(res, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const result = await service.submitIntake(intakeId, intakeContext(record2.projectId));
+    sendJson2(res, 200, result);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeCancel(res, req, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  const body = await readJsonBody3(res, req);
+  if (body === null) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const reason = typeof body["reason"] === "string" ? body["reason"] : void 0;
+    const updated = await service.cancelIntake(intakeId, intakeContext(record2.projectId), reason);
+    sendJson2(res, 200, updated);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeArchive(res, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const record2 = await discoverIntake(res, service, intakeId);
+    if (!record2) return;
+    const updated = await service.archiveIntake(intakeId, intakeContext(record2.projectId));
+    sendJson2(res, 200, updated);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+
 // src/server/memory-diagnostics.ts
 import * as fs8 from "node:fs/promises";
 import * as path11 from "node:path";
@@ -8571,7 +9017,7 @@ async function touchProjectInManifest(options, globalConfigPath) {
 // src/server/techstack-handlers.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 var DEEP_DIVE_TIMEOUT_MS = 6e4;
-function sendJson2(res, status, data) {
+function sendJson3(res, status, data) {
   res.writeHead(status, { "Content-Type": "application/json" });
   res.end(JSON.stringify(data));
 }
@@ -8586,13 +9032,13 @@ function handleTechStackSnapshot(res, deps2) {
   try {
     const snapshot = deps2.store.getSnapshot(deps2.projectId);
     if (!snapshot) {
-      sendJson2(res, 404, { snapshot: null, stale: false });
+      sendJson3(res, 404, { snapshot: null, stale: false });
       return;
     }
     const ageMs = Date.now() - new Date(snapshot.createdAt).getTime();
-    sendJson2(res, 200, { snapshot, stale: ageMs > 24 * 60 * 60 * 1e3 });
+    sendJson3(res, 200, { snapshot, stale: ageMs > 24 * 60 * 60 * 1e3 });
   } catch (error2) {
-    sendJson2(res, 500, {
+    sendJson3(res, 500, {
       error: "TechStack store unavailable",
       detail: errorMessage(error2)
     });
@@ -8603,7 +9049,7 @@ function errorMessage(error2) {
 }
 function requireJobDeps(res, deps2) {
   if (!deps2.projectRoot || !deps2.engine) {
-    sendJson2(res, 503, { error: "TechStack engine unavailable" });
+    sendJson3(res, 503, { error: "TechStack engine unavailable" });
     return false;
   }
   return true;
@@ -8614,7 +9060,7 @@ function startJob(res, deps2, kind) {
   const controller = new AbortController();
   deps2.runningJobs?.set(jobId, controller);
   deps2.emit?.({ type: "techstack.job.started", payload: { jobId, kind } });
-  sendJson2(res, 202, { jobId, kind, status: "queued" });
+  sendJson3(res, 202, { jobId, kind, status: "queued" });
   void buildResearcher(deps2, kind).catch(() => void 0).then(
     (researcher) => deps2.engine.analyze(deps2.projectId, {
       targetRoot: deps2.projectRoot,
@@ -8660,24 +9106,24 @@ function handleTechStackCancel(res, deps2, jobId) {
   if (controller && !controller.signal.aborted) controller.abort();
   deps2.store.updateJobStatus(jobId, "cancelled");
   deps2.emit?.({ type: "techstack.job.cancelled", payload: { jobId } });
-  sendJson2(res, 200, { jobId, status: "cancelled" });
+  sendJson3(res, 200, { jobId, status: "cancelled" });
 }
 async function handleTechStackDependencyResearch(res, deps2, dependencyId) {
   const snapshot = deps2.store.getSnapshot(deps2.projectId);
   const dependency = snapshot?.dependencies.find((dep) => dep.id === dependencyId);
   if (!dependency) {
-    sendJson2(res, 404, { error: "Dependency not found in the current snapshot" });
+    sendJson3(res, 404, { error: "Dependency not found in the current snapshot" });
     return;
   }
   let researcher;
   try {
     researcher = await buildResearcher(deps2, "analyze");
   } catch (error2) {
-    sendJson2(res, 503, { error: "Research unavailable", detail: errorMessage(error2) });
+    sendJson3(res, 503, { error: "Research unavailable", detail: errorMessage(error2) });
     return;
   }
   if (!researcher) {
-    sendJson2(res, 503, {
+    sendJson3(res, 503, {
       error: "No model configured \u2014 connect a provider to run LLM analysis."
     });
     return;
@@ -8694,9 +9140,9 @@ async function handleTechStackDependencyResearch(res, deps2, dependencyId) {
       [triaged ?? { dependency, cluster: "breaking_change", priority: 0 }],
       { signal: controller.signal }
     );
-    sendJson2(res, 200, { dependencyId, findings });
+    sendJson3(res, 200, { dependencyId, findings });
   } catch (error2) {
-    sendJson2(res, 500, { error: "Research failed", detail: errorMessage(error2) });
+    sendJson3(res, 500, { error: "Research failed", detail: errorMessage(error2) });
   } finally {
     clearTimeout(timeout);
     controller.abort();
@@ -8705,15 +9151,15 @@ async function handleTechStackDependencyResearch(res, deps2, dependencyId) {
 function handleTechStackJobStatus(res, deps2, jobId) {
   const job = deps2.store.getJob(jobId);
   if (!job) {
-    sendJson2(res, 404, { error: "Job not found" });
+    sendJson3(res, 404, { error: "Job not found" });
     return;
   }
-  sendJson2(res, 200, { job });
+  sendJson3(res, 200, { job });
 }
 function handleTechStackReport(res, deps2, reportId, format) {
   const snapshot = deps2.store.getSnapshotById(reportId);
   if (!snapshot) {
-    sendJson2(res, 404, { error: "Report not found" });
+    sendJson3(res, 404, { error: "Report not found" });
     return;
   }
   if (deps2.engine) {
@@ -8724,30 +9170,30 @@ function handleTechStackReport(res, deps2, reportId, format) {
     });
     res.end(report);
   } else {
-    sendJson2(res, 200, snapshot);
+    sendJson3(res, 200, snapshot);
   }
 }
 async function handleTechStackTrends(res, deps2) {
   try {
     const { TrendStore } = await import("@wrongstack/techstack");
-    sendJson2(res, 200, { trend: new TrendStore(deps2.store).analyze(deps2.projectId) });
+    sendJson3(res, 200, { trend: new TrendStore(deps2.store).analyze(deps2.projectId) });
   } catch (error2) {
-    sendJson2(res, 500, { error: "Trend analysis failed", detail: errorMessage(error2) });
+    sendJson3(res, 500, { error: "Trend analysis failed", detail: errorMessage(error2) });
   }
 }
 async function handleTechStackRemediationPlan(res, deps2) {
   const snapshot = deps2.store.getSnapshot(deps2.projectId);
   if (!snapshot) {
-    sendJson2(res, 404, { error: "No TechStack snapshot is available" });
+    sendJson3(res, 404, { error: "No TechStack snapshot is available" });
     return;
   }
   const { applyPlan, generateUpgradePlan } = await import("@wrongstack/techstack");
   const plan = generateUpgradePlan(snapshot);
-  sendJson2(res, 200, { plan, preview: await applyPlan(plan) });
+  sendJson3(res, 200, { plan, preview: await applyPlan(plan) });
 }
 async function handleTechStackRemediationApply(req, res, deps2) {
   if (!deps2.executePackageOperation) {
-    sendJson2(res, 503, { error: "Permission-governed package execution is unavailable" });
+    sendJson3(res, 503, { error: "Permission-governed package execution is unavailable" });
     return;
   }
   let approvedItems;
@@ -8760,16 +9206,16 @@ async function handleTechStackRemediationApply(req, res, deps2) {
     const body = JSON.parse(raw || "{}");
     approvedItems = Array.isArray(body.approvedItems) ? body.approvedItems.filter((value) => typeof value === "string") : [];
   } catch (error2) {
-    sendJson2(res, 400, { error: "Invalid request body", detail: errorMessage(error2) });
+    sendJson3(res, 400, { error: "Invalid request body", detail: errorMessage(error2) });
     return;
   }
   if (approvedItems.length === 0) {
-    sendJson2(res, 400, { error: "approvedItems must explicitly identify at least one plan item" });
+    sendJson3(res, 400, { error: "approvedItems must explicitly identify at least one plan item" });
     return;
   }
   const snapshot = deps2.store.getSnapshot(deps2.projectId);
   if (!snapshot) {
-    sendJson2(res, 404, { error: "No TechStack snapshot is available" });
+    sendJson3(res, 404, { error: "No TechStack snapshot is available" });
     return;
   }
   const approved = new Set(approvedItems);
@@ -8784,14 +9230,17 @@ async function handleTechStackRemediationApply(req, res, deps2) {
       return executePackageOperation(operation, workspace?.relativeRoot);
     }
   });
-  sendJson2(res, 200, { plan, result });
+  sendJson3(res, 200, { plan, result });
 }
 
 // src/server/ws-auth.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { timingSafeEqual } from "node:crypto";
+import { isLoopbackHost as isLoopbackHostCore } from "@wrongstack/core/hq";
 function isLoopbackHostname(hostname) {
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+  const normalized = hostname.toLowerCase();
+  if (normalized === "localhost") return true;
+  return isLoopbackHostCore(normalized);
 }
 function effectivePort(url) {
   if (url.port) return url.port;
@@ -8812,7 +9261,7 @@ function isTrustedLoopbackOrigin(origin, hostHeader) {
   }
 }
 function isLoopbackBind(wsHost) {
-  return wsHost === "127.0.0.1" || wsHost === "::1" || wsHost === "localhost";
+  return isLoopbackHostCore(wsHost) || wsHost === "localhost";
 }
 function isWildcardBind(wsHost) {
   return wsHost === "0.0.0.0" || wsHost === "::" || wsHost === "[::]";
@@ -8839,19 +9288,22 @@ function extractToken(url) {
 function extractTokenFromCookie(cookieHeader) {
   if (!cookieHeader) return void 0;
   const raw = Array.isArray(cookieHeader) ? cookieHeader.join("; ") : cookieHeader;
+  let plain;
   for (const part of raw.split(";")) {
     const eq = part.indexOf("=");
     if (eq < 0) continue;
     const name2 = part.slice(0, eq).trim();
-    if (name2 === "ws_token") {
-      try {
-        return decodeURIComponent(part.slice(eq + 1).trim());
-      } catch {
-        return part.slice(eq + 1).trim();
-      }
+    if (name2 !== "ws_token" && name2 !== "__Host-ws_token") continue;
+    let value;
+    try {
+      value = decodeURIComponent(part.slice(eq + 1).trim());
+    } catch {
+      value = part.slice(eq + 1).trim();
     }
+    if (name2 === "__Host-ws_token") return value;
+    plain ??= value;
   }
-  return void 0;
+  return plain;
 }
 function hostHeaderOk(input) {
   if (!isLoopbackBind(input.wsHost)) return true;
@@ -8893,7 +9345,8 @@ function verifyClient(input) {
     expectedToken,
     requireToken,
     allowedHostnames,
-    allowBrowserUrlToken
+    allowBrowserUrlToken,
+    allowCrossPortLoopbackCookie
   } = input;
   const urlTokenOk = tokenMatches(extractToken(url ?? ""), expectedToken);
   const cookieTokenOk = tokenMatches(extractTokenFromCookie(cookieHeader), expectedToken);
@@ -8908,7 +9361,10 @@ function verifyClient(input) {
     const { hostname: originHostname } = new URL(origin);
     if (isLoopbackHostname(originHostname)) {
       if (requireToken || !isLoopbackBind(wsHost)) return cookieTokenOk;
-      return cookieTokenOk || isTrustedLoopbackOrigin(origin, hostHeader);
+      if (!isTrustedLoopbackOrigin(origin, hostHeader)) {
+        return Boolean(allowCrossPortLoopbackCookie) && cookieTokenOk;
+      }
+      return true;
     }
     return cookieTokenOk || Boolean(allowBrowserUrlToken) && urlTokenOk && allowedHostname(originHostname, allowedHostnames);
   } catch {
@@ -8943,11 +9399,22 @@ ${out}`;
 function firstHeader(value) {
   return Array.isArray(value) ? value[0] : value;
 }
-function wsTokenCookie(token) {
-  return `ws_token=${encodeURIComponent(token)}; HttpOnly; SameSite=Strict; Path=/; Max-Age=3600`;
+var WS_TOKEN_COOKIE = "ws_token";
+var WS_TOKEN_COOKIE_SECURE = "__Host-ws_token";
+function wsTokenCookie(token, secure) {
+  const name2 = secure ? WS_TOKEN_COOKIE_SECURE : WS_TOKEN_COOKIE;
+  const parts = [
+    `${name2}=${encodeURIComponent(token)}`,
+    "HttpOnly",
+    "SameSite=Strict",
+    "Path=/",
+    "Max-Age=3600"
+  ];
+  if (secure) parts.push("Secure");
+  return parts.join("; ");
 }
-function setAuthCookieHeaders(res, token) {
-  res.setHeader("Set-Cookie", wsTokenCookie(token));
+function setAuthCookieHeaders(res, token, secure) {
+  res.setHeader("Set-Cookie", wsTokenCookie(token, secure));
   res.setHeader("Cache-Control", "no-store");
 }
 function setStaticSecurityHeaders(res) {
@@ -8955,8 +9422,16 @@ function setStaticSecurityHeaders(res) {
   res.setHeader("X-Frame-Options", "DENY");
   res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
 }
-function requestToken(req, url) {
-  return url.searchParams.get("token") ?? firstHeader(req.headers["x-ws-token"]) ?? extractTokenFromCookie(req.headers.cookie);
+function requestToken(req, url, opts = {}) {
+  const queryToken = url.searchParams.get("token") ?? void 0;
+  if (queryToken !== void 0 && (opts.allowQuery === true || isLoopbackPeer(req))) {
+    return queryToken;
+  }
+  return firstHeader(req.headers["x-ws-token"]) ?? extractTokenFromCookie(req.headers.cookie);
+}
+function isLoopbackPeer(req) {
+  const address = req.socket.remoteAddress?.replace(/^::ffff:/i, "");
+  return address !== void 0 && isLoopbackHostname(address);
 }
 function formatCspHostname(hostname) {
   return hostname.includes(":") && !hostname.startsWith("[") ? `[${hostname}]` : hostname;
@@ -9011,7 +9486,8 @@ function strictDecodeParam(segment, res) {
 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 requireAccessToken = true;
+  const secureCookies = opts.secureCookies ?? (opts.publicWsUrl?.trim().toLowerCase().startsWith("wss:") ?? false);
   const trustedHostnames = (() => {
     const names = [...opts.allowedHostnames ?? []];
     if (opts.publicWsUrl) {
@@ -9050,13 +9526,13 @@ function createHttpServer(opts) {
       const accessTokenOk = Boolean(opts.apiToken) && tokenMatches(providedAccessToken, opts.apiToken ?? "");
       const shouldSetAuthCookie = Boolean(opts.apiToken) && tokenMatches(url.searchParams.get("token") ?? void 0, opts.apiToken ?? "");
       if (url.pathname === "/ws-auth" && req.method === "GET" && (opts.enableWsCookie ?? true)) {
-        const provided = requestToken(req, url);
+        const provided = requestToken(req, url, { allowQuery: true });
         if (!provided || !opts.apiToken || !tokenMatches(provided, opts.apiToken)) {
           res.writeHead(401, { "Content-Type": "text/plain" });
           res.end("Unauthorized");
           return;
         }
-        setAuthCookieHeaders(res, opts.apiToken);
+        setAuthCookieHeaders(res, opts.apiToken, secureCookies);
         res.writeHead(200, { "Content-Type": "text/plain" });
         res.end("ok");
         return;
@@ -9070,7 +9546,7 @@ function createHttpServer(opts) {
         return;
       }
       if (shouldSetAuthCookie && opts.apiToken) {
-        setAuthCookieHeaders(res, opts.apiToken);
+        setAuthCookieHeaders(res, opts.apiToken, secureCookies);
       }
       if (url.pathname === "/api/fleet/ping" && req.method === "POST") {
         if (requireAccessToken && !accessTokenOk) {
@@ -9188,6 +9664,88 @@ function createHttpServer(opts) {
         await handleApiAnalyticsSummary(res);
         return;
       }
+      if (url.pathname === "/api/requirement-intakes" && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        await handleRequirementIntakeListForServer(res, opts.intakeService, opts.projectRoot);
+        return;
+      }
+      const intakeProjectMatch = url.pathname.match(
+        /^\/api\/projects\/([^/]+)\/requirement-intakes$/
+      );
+      if (intakeProjectMatch && req.method === "POST") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        await handleRequirementIntakeCreate(
+          res,
+          req,
+          opts.intakeService,
+          decodeURIComponent(intakeProjectMatch[1])
+        );
+        return;
+      }
+      if (intakeProjectMatch && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        await handleRequirementIntakeList(
+          res,
+          opts.intakeService,
+          decodeURIComponent(intakeProjectMatch[1])
+        );
+        return;
+      }
+      const intakeIdMatch = url.pathname.match(/^\/api\/requirement-intakes\/([^/]+)$/);
+      if (intakeIdMatch && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        await handleRequirementIntakeGet(res, opts.intakeService, intakeIdMatch[1]);
+        return;
+      }
+      if (intakeIdMatch && req.method === "PATCH") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        await handleRequirementIntakeUpdate(res, req, opts.intakeService, intakeIdMatch[1]);
+        return;
+      }
+      const intakeActionMatch = url.pathname.match(
+        /^\/api\/requirement-intakes\/([^/]+)\/(answers|suggestions|submit|cancel|archive)$/
+      );
+      if (intakeActionMatch && req.method === "POST") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        const intakeId = intakeActionMatch[1];
+        const action = intakeActionMatch[2];
+        if (action === "answers") {
+          await handleRequirementIntakeAnswers(res, req, opts.intakeService, intakeId);
+        } else if (action === "suggestions") {
+          await handleRequirementIntakeSuggestions(res, req, opts.intakeService, intakeId);
+        } else if (action === "submit") {
+          await handleRequirementIntakeSubmit(res, opts.intakeService, intakeId);
+        } else if (action === "cancel") {
+          await handleRequirementIntakeCancel(res, req, opts.intakeService, intakeId);
+        } else {
+          await handleRequirementIntakeArchive(res, opts.intakeService, intakeId);
+        }
+        return;
+      }
       if (url.pathname === "/api/codemap/packages" && req.method === "GET") {
         if (requireAccessToken && !accessTokenOk) {
           res.writeHead(401, { "Content-Type": "application/json" });
@@ -9383,17 +9941,25 @@ function createHttpServer(opts) {
           res.end(JSON.stringify({ error: "Project root not configured" }));
           return;
         }
-        await handleDeadCodeScan(res, {
-          projectRoot: opts.projectRoot,
-          indexDir: opts.indexDir
-        }, req);
+        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);
+        await handleDeadCodeActionPlan(
+          res,
+          {
+            projectRoot: opts.projectRoot ?? "",
+            indexDir: opts.indexDir
+          },
+          req
+        );
         return;
       }
       if (url.pathname === "/api" || url.pathname.startsWith("/api/")) {
@@ -11696,6 +12262,55 @@ import {
   restartMcp,
   updateMcp
 } from "@wrongstack/mcp";
+
+// src/server/privileged-actions.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import {
+  isTrustDecisionAllowed
+} from "@wrongstack/core/security";
+async function authorizeWebUIAction(boundary, action, logger) {
+  const request = {
+    version: 1,
+    requestId: randomUUID3(),
+    actor: {
+      kind: "remote-client",
+      ...action.sessionId ? { sessionId: action.sessionId } : {}
+    },
+    surface: "webui",
+    capability: action.capability,
+    subject: action.subject,
+    risk: action.risk,
+    scope: {
+      ...action.cwd ? { cwd: action.cwd } : {},
+      ...action.sessionId ? { sessionId: action.sessionId } : {}
+    },
+    authContext: { method: "session" },
+    ...action.metadata ? { metadata: action.metadata } : {}
+  };
+  const decision = await boundary.evaluate(request);
+  logger?.debug?.(
+    `[trust-boundary] ${request.capability} ${decision.kind} request=${request.requestId}`
+  );
+  return { allowed: isTrustDecisionAllowed(decision), reason: decision.reason, request };
+}
+
+// src/server/mcp-handlers.ts
+async function authorizeMcpMutation(ws, operation, serverName, trustBoundary) {
+  if (!trustBoundary) return true;
+  const authorization = await authorizeWebUIAction(trustBoundary, {
+    capability: "mcp.server.configure",
+    subject: { kind: "process", id: serverName },
+    risk: "elevated",
+    metadata: { transport: "websocket", operation }
+  });
+  if (!authorization.allowed) {
+    send(ws, {
+      type: "mcp.operation_result",
+      payload: { success: false, message: `${operation} denied: ${authorization.reason}` }
+    });
+  }
+  return authorization.allowed;
+}
 function mapStatus(raw) {
   switch (raw) {
     case "connected":
@@ -11770,7 +12385,7 @@ async function handleMcpList(ws, _msg, globalConfigPath, mcpRegistry) {
     payload: { servers: servers.map((server) => toView(server, health.get(server.name))) }
   });
 }
-async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
+async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry, trustBoundary) {
   const d = deps(ws, globalConfigPath, mcpRegistry);
   if (!d) return;
   const validated = validateMcpServerPayload(msg.payload, "mcp.add");
@@ -11781,6 +12396,7 @@ async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
     });
     return;
   }
+  if (!await authorizeMcpMutation(ws, "mcp.add", name(msg), trustBoundary)) return;
   const result = await addMcp(validated.value, d);
   if (result.ok && result.server) {
     send(ws, { type: "mcp.server.added", payload: { server: toView(result.server) } });
@@ -11798,7 +12414,7 @@ async function handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry) {
     payload: { success: result.ok, message: result.message }
   });
 }
-async function handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry) {
+async function handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry, trustBoundary) {
   const d = deps(ws, globalConfigPath, mcpRegistry);
   if (!d) return;
   const validated = validateMcpServerPayload(msg.payload, "mcp.update");
@@ -11809,6 +12425,7 @@ async function handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry) {
     });
     return;
   }
+  if (!await authorizeMcpMutation(ws, "mcp.update", name(msg), trustBoundary)) return;
   const result = await updateMcp(validated.value, d);
   if (result.ok && result.server) {
     send(ws, { type: "mcp.server.updated", payload: { server: toView(result.server) } });
@@ -12952,7 +13569,7 @@ function openBrowser(url, platform = process.platform) {
 }
 
 // src/server/port-utils.ts
-import * as net3 from "node:net";
+import * as net2 from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
 var SURFACE_DEFAULT_PORTS = {
   webui: { http: 3456 },
@@ -12966,7 +13583,7 @@ function getSurfaceDefaultPorts(surface) {
 }
 function isPortFree(host, port) {
   return new Promise((resolve16) => {
-    const srv = net3.createServer();
+    const srv = net2.createServer();
     srv.once("error", () => resolve16(false));
     srv.once("listening", () => {
       srv.close(() => resolve16(true));
@@ -13000,6 +13617,27 @@ import { spawn as spawn2 } from "node:child_process";
 import { existsSync } from "node:fs";
 import { findPackageJSON } from "node:module";
 import * as path15 from "node:path";
+
+// src/server/intake-service.ts
+import { resolveWstackPaths as resolveWstackPaths4 } from "@wrongstack/core/utils";
+import {
+  AllowAllIntakeAuthorizer,
+  RequirementIntakeService,
+  RequirementIntakeStore
+} from "@wrongstack/requirement-intake";
+function createProjectIntakeService(opts) {
+  return new RequirementIntakeService({
+    store: new RequirementIntakeStore({
+      baseDir: resolveWstackPaths4({
+        projectRoot: opts.projectRoot,
+        globalRoot: opts.globalRoot
+      }).projectRequirementIntakes
+    }),
+    authorizer: new AllowAllIntakeAuthorizer()
+  });
+}
+
+// src/server/frontend-static-serve.ts
 function resolveDistDir(input) {
   const options = typeof input === "string" ? { explicitDistDir: input } : input ?? {};
   if (options.explicitDistDir) return path15.resolve(options.explicitDistDir);
@@ -13084,6 +13722,10 @@ async function startStaticServe(opts, deps2 = {}) {
   const create = deps2.createServer ?? createHttpServer;
   const distDir = deps2.resolveDist ? deps2.resolveDist(opts.distDir) : await ensureDist(opts.distDir);
   if (distDir === null) return null;
+  const intakeService = opts.intakeService ?? (opts.projectRoot ? createProjectIntakeService({
+    projectRoot: opts.projectRoot,
+    globalRoot: opts.globalRoot
+  }) : void 0);
   const server = create({
     host: opts.host,
     port: opts.httpPort,
@@ -13096,7 +13738,8 @@ async function startStaticServe(opts, deps2 = {}) {
     publicWsUrl: opts.publicWsUrl,
     apiToken: opts.apiToken,
     requireToken: opts.requireToken,
-    allowedHostnames: opts.allowedHostnames
+    allowedHostnames: opts.allowedHostnames,
+    intakeService
   });
   if (!opts.deferListen) {
     server.listen(opts.httpPort, opts.host);
@@ -13201,7 +13844,8 @@ function registerWebuiInstance(p, deps2 = {}) {
         host: p.host,
         port: p.httpPort,
         publicUrl: p.publicUrl
-      })
+      }),
+      ...p.authToken ? { authToken: p.authToken } : {}
     },
     p.registryBaseDir
   ).catch(() => {
@@ -13235,10 +13879,31 @@ ${extraBlock}`
     if (p.open) launch(openUrl);
   });
 }
+var DEFAULT_CHILD_CLEANUP_TIMEOUT_MS = 1e4;
+async function runBounded(work, timeoutMs, label, debug) {
+  let timer;
+  try {
+    await Promise.race([
+      Promise.resolve().then(() => work()).catch((err) => {
+        debug(`[webui-server] ${label} failed: ${err}`);
+      }),
+      new Promise((resolve16) => {
+        timer = setTimeout(() => {
+          debug(`[webui-server] ${label} timed out after ${timeoutMs}ms`);
+          resolve16();
+        }, timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function createWebuiShutdown(res) {
   const log = res.log ?? ((m) => console.log(m));
   const debug = res.debug ?? ((m) => console.debug(m));
   const unregister = res.unregisterFn ?? unregisterInstance;
+  const childTimeout = Math.max(1, res.childCleanupTimeoutMs ?? DEFAULT_CHILD_CLEANUP_TIMEOUT_MS);
   let started = false;
   return () => {
     if (started) return;
@@ -13246,17 +13911,30 @@ function createWebuiShutdown(res) {
     log("[WebUI] Shutting down...");
     res.abortInFlight();
     res.unsubscribeEvents();
-    res.disposeResources?.();
-    res.closeClients();
-    const unregistered = unregister(res.pid, res.registryBaseDir).catch(
-      (err) => debug(`[webui-server] unregister failed: ${err}`)
-    );
-    res.closeHttpServer();
-    res.wss.close(() => {
-      void unregistered.then(() => {
-        log("[WebUI] Server stopped");
-        res.onStopped();
+    void (async () => {
+      if (res.stopOwnedChildren) {
+        await runBounded(res.stopOwnedChildren, childTimeout, "stopOwnedChildren", debug);
+      }
+      if (res.disposeResources) {
+        await runBounded(res.disposeResources, Math.min(childTimeout, 5e3), "disposeResources", debug);
+      }
+      res.closeClients();
+      res.closeHttpServer();
+      const unregistered = unregister(res.pid, res.registryBaseDir).catch(
+        (err) => debug(`[webui-server] unregister failed: ${err}`)
+      );
+      await new Promise((resolve16) => {
+        res.wss.close(() => resolve16());
       });
+      await unregistered;
+      log("[WebUI] Server stopped");
+      res.onStopped();
+    })().catch((err) => {
+      debug(`[webui-server] shutdown sequence failed: ${err}`);
+      try {
+        res.onStopped();
+      } catch {
+      }
     });
   };
 }
@@ -13511,7 +14189,21 @@ function createWebuiClientPresence(deps2) {
 }
 
 // src/server/brain-handlers.ts
+import { BUILTIN_COUNCIL_PERSONAS } from "@wrongstack/core/execution";
 import { toErrorMessage as toErrorMessage5 } from "@wrongstack/core/utils";
+var COUNCIL_PERSONA_CATALOG = Object.freeze(
+  BUILTIN_COUNCIL_PERSONAS.map(
+    (persona) => Object.freeze({
+      id: persona.id,
+      name: persona.name,
+      description: persona.description,
+      ...persona.defaultVeto !== void 0 ? { defaultVeto: persona.defaultVeto } : {}
+    })
+  )
+);
+function brainConfigPayload(runtime) {
+  return { ...runtime.getSnapshot(), personaCatalog: COUNCIL_PERSONA_CATALOG };
+}
 function sendResult6(ctx, ws, success, message) {
   ctx.send(ws, { type: "key.operation_result", payload: { success, message } });
 }
@@ -13551,7 +14243,7 @@ function handleBrainConfigGet(ctx, ws) {
   }
   ctx.send(ws, {
     type: "brain.config",
-    payload: { config: ctx.brainRuntime.getSnapshot(), persisted: true }
+    payload: { config: brainConfigPayload(ctx.brainRuntime), persisted: true }
   });
 }
 async function handleBrainConfigSet(ctx, ws, payload) {
@@ -13575,7 +14267,7 @@ async function handleBrainConfigSet(ctx, ws, payload) {
     ctx.send(ws, {
       type: "brain.config",
       payload: {
-        config: ctx.brainRuntime.getSnapshot(),
+        config: brainConfigPayload(ctx.brainRuntime),
         persisted: result.ok,
         ...result.ok ? {} : { error: result.error ?? "Persist failed." }
       }
@@ -13585,7 +14277,7 @@ async function handleBrainConfigSet(ctx, ws, payload) {
     ctx.send(ws, {
       type: "brain.config",
       payload: {
-        config: ctx.brainRuntime.getSnapshot(),
+        config: brainConfigPayload(ctx.brainRuntime),
         persisted: false,
         error: `Invalid Brain setting: ${toErrorMessage5(err)}`
       }
@@ -14350,6 +15042,8 @@ function buildAuditPrompt(board, health) {
 
 // src/server/context-meta.ts
 import { FallbackProfileManager } from "@wrongstack/core/agent";
+import { resolvePluginEnablement } from "@wrongstack/core/plugin";
+import { FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS2 } from "@wrongstack/core/utils";
 function seedContextMeta(config, context) {
   const meta = context.meta;
   const autonomyCfg = config.autonomy ?? {};
@@ -14426,6 +15120,21 @@ function seedContextMeta(config, context) {
   meta["tgDelegate"] = tgExt?.["notifyOnDelegate"] !== false;
   const tgMs = tgExt?.["longToolThresholdMs"];
   meta["tgLongToolMs"] = typeof tgMs === "number" ? tgMs : 3e4;
+  {
+    const pluginsEnabled = {};
+    const record2 = (name2) => {
+      if (FORBIDDEN_PROTO_KEYS2.has(name2) || name2 in pluginsEnabled) return;
+      pluginsEnabled[name2] = resolvePluginEnablement({ name: name2, config }).enabled;
+    };
+    for (const entry of config.plugins ?? []) {
+      const name2 = typeof entry === "string" ? entry : entry?.name;
+      if (typeof name2 === "string") record2(name2);
+    }
+    for (const [name2, options] of Object.entries(config.extensions ?? {})) {
+      if (typeof options?.["enabled"] === "boolean") record2(name2);
+    }
+    if (Object.keys(pluginsEnabled).length > 0) meta["pluginsEnabled"] = pluginsEnabled;
+  }
   const chimeraExt = config.extensions?.["wstack-chimera"];
   meta["chimeraEnabled"] = chimeraExt?.["enabled"] === true;
   meta["chimeraProvider"] = chimeraExt?.["provider"] ?? "";
@@ -14463,8 +15172,9 @@ function seedContextMeta(config, context) {
 // src/server/pref-helpers.ts
 import * as fs13 from "node:fs/promises";
 import * as path18 from "node:path";
+import { pluginEntryMatchesName } from "@wrongstack/core/plugin";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets } from "@wrongstack/core/security";
-import { atomicWrite as atomicWrite6, backupConfigFile, FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS2 } from "@wrongstack/core/utils";
+import { atomicWrite as atomicWrite6, backupConfigFile, FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS3 } from "@wrongstack/core/utils";
 var PREF_KEYS = [
   "autonomy",
   "autonomyDelayMs",
@@ -14545,6 +15255,8 @@ var PREF_KEYS = [
   // Display-only toggles (purely visual WebUI prefs, not persisted to config).
   "groupToolCalls",
   "showThinkingLogs",
+  // v15: chat-input auto-collapse (opt-in display toggle, default off).
+  "autoCollapseInput",
   // Per-plugin enable/disable map (parity with the embedded server).
   "pluginsEnabled",
   // Fleet chat verbosity: off | full (migrated from streamFleet boolean).
@@ -14599,6 +15311,8 @@ async function updateGlobalConfig(deps2, holder, mutate, errorLabel) {
 var DISPLAY_ONLY_KEYS = /* @__PURE__ */ new Set([
   "groupToolCalls",
   "showThinkingLogs",
+  // v15: chat-input auto-collapse (opt-in display toggle, default off).
+  "autoCollapseInput",
   "autoReviewFallbackModels",
   // v11 Display parity: agent-swarm panel + inverse fsAccess flag.
   // The TUI settings picker mirrors these so the browser can keep the
@@ -14809,15 +15523,29 @@ async function persistPrefsToConfig(deps2, holder, payload) {
         decrypted.debugStream = payload["debugStream"];
       if (typeof payload["pluginsEnabled"] === "object" && payload["pluginsEnabled"] !== null) {
         const ext = decrypted.extensions ?? {};
+        const toggled = [];
         for (const [pluginName, enabled] of Object.entries(
           payload["pluginsEnabled"]
         )) {
-          if (FORBIDDEN_PROTO_KEYS2.has(pluginName)) continue;
+          if (FORBIDDEN_PROTO_KEYS3.has(pluginName)) continue;
+          if (typeof enabled !== "boolean") continue;
           const pExt = ext[pluginName] ?? {};
           pExt["enabled"] = enabled;
           ext[pluginName] = pExt;
+          toggled.push([pluginName, enabled]);
         }
         decrypted.extensions = ext;
+        if (Array.isArray(decrypted.plugins) && toggled.length > 0) {
+          decrypted.plugins = decrypted.plugins.map((entry) => {
+            const entryName = typeof entry === "string" ? entry : entry?.name;
+            if (typeof entryName !== "string") return entry;
+            const hit = toggled.find(([name2]) => pluginEntryMatchesName(entryName, name2));
+            if (!hit) return entry;
+            const [, enabled] = hit;
+            if (typeof entry === "string") return enabled ? entry : { name: entry, enabled: false };
+            return { ...entry, enabled };
+          });
+        }
       }
       const chimeraTouched = typeof payload["chimeraEnabled"] === "boolean" || typeof payload["chimeraProvider"] === "string" || typeof payload["chimeraModel"] === "string" || typeof payload["chimeraMaxFiles"] === "number" || typeof payload["chimeraAutoFix"] === "string";
       if (chimeraTouched) {
@@ -14926,39 +15654,6 @@ async function handlePrefsRoute(ws, msg, handlers) {
 // src/server/process-handlers.ts
 import { createCompatibilityTrustBoundary } from "@wrongstack/core/security";
 import { getProcessRegistry as getProcessRegistry2 } from "@wrongstack/tools";
-
-// src/server/privileged-actions.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import {
-  isTrustDecisionAllowed
-} from "@wrongstack/core/security";
-async function authorizeWebUIAction(boundary, action, logger) {
-  const request = {
-    version: 1,
-    requestId: randomUUID4(),
-    actor: {
-      kind: "remote-client",
-      ...action.sessionId ? { sessionId: action.sessionId } : {}
-    },
-    surface: "webui",
-    capability: action.capability,
-    subject: action.subject,
-    risk: action.risk,
-    scope: {
-      ...action.cwd ? { cwd: action.cwd } : {},
-      ...action.sessionId ? { sessionId: action.sessionId } : {}
-    },
-    authContext: { method: "session" },
-    ...action.metadata ? { metadata: action.metadata } : {}
-  };
-  const decision = await boundary.evaluate(request);
-  logger?.debug?.(
-    `[trust-boundary] ${request.capability} ${decision.kind} request=${request.requestId}`
-  );
-  return { allowed: isTrustDecisionAllowed(decision), reason: decision.reason, request };
-}
-
-// src/server/process-handlers.ts
 function handleProcessList(ws) {
   try {
     const procs = getProcessRegistry2().list();
@@ -15069,7 +15764,7 @@ import { makeProviderFromConfig } from "@wrongstack/providers";
 import * as fs14 from "node:fs/promises";
 import * as path19 from "node:path";
 import { DefaultSessionStore } from "@wrongstack/core/storage";
-import { resolveWstackPaths as resolveWstackPaths4 } from "@wrongstack/core/utils";
+import { resolveWstackPaths as resolveWstackPaths5 } from "@wrongstack/core/utils";
 function createProjectHandlers(ctx) {
   const sendTo = (ws, message) => {
     if (ctx.sendMessage) ctx.sendMessage(ws, message);
@@ -15187,7 +15882,7 @@ function createProjectHandlers(ctx) {
           });
           return;
         }
-        const paths = resolveWstackPaths4({
+        const paths = resolveWstackPaths5({
           projectRoot: resolved,
           globalRoot: ctx.wpaths.globalRoot
         });
@@ -15198,7 +15893,7 @@ function createProjectHandlers(ctx) {
         const previous = ctx.getSession();
         const previousId = previous.id;
         const previousProjectRoot = ctx.getProjectRoot();
-        const previousPaths = resolveWstackPaths4({
+        const previousPaths = resolveWstackPaths5({
           projectRoot: previousProjectRoot,
           globalRoot: ctx.wpaths.globalRoot
         });
@@ -15782,8 +16477,10 @@ function createProviderOperations(deps2) {
       if (result.ok) {
         deps2.log?.(`[WebUI] Provider "${payload.id}" added via provider.add`);
       }
+      return result.ok;
     } catch (err) {
       sendOperationResult(ws, false, errMessage(err));
+      return false;
     }
   }
   async function handleProviderRemove(ws, providerId) {
@@ -16167,6 +16864,7 @@ var CLIENT_CONVERSATION_MESSAGE_TYPES = [
   "completion.request",
   "model.switch",
   "model.refine",
+  "model.fallback_choice",
   "autonomy.switch",
   "context.clear",
   "context.compact",
@@ -16184,6 +16882,7 @@ var CLIENT_CONVERSATION_MESSAGE_TYPES = [
   "modes.list",
   "session.checkpoints",
   "session.delete",
+  "session.inspect",
   "session.new",
   "session.rename",
   "session.resume",
@@ -16437,6 +17136,7 @@ var SERVER_CONVERSATION_MESSAGE_TYPES = [
   "provider.active_blocked",
   "provider.error",
   "provider.fallback",
+  "provider.fallback_pending",
   "provider.response",
   "provider.retry",
   "provider.status_changed",
@@ -16447,6 +17147,7 @@ var SERVER_CONVERSATION_MESSAGE_TYPES = [
   "session.checkpoints",
   "session.damaged",
   "session.end",
+  "session.inspect",
   "session.rewound",
   "session.start",
   "session.stats",
@@ -16477,6 +17178,7 @@ var SERVER_COLLABORATION_MESSAGE_TYPES = [
   "collab.state",
   "mailbox.action_result",
   "mailbox.agent_registered",
+  "mailbox.agent_deregistered",
   "mailbox.agents",
   "mailbox.cleared",
   "mailbox.compacted",
@@ -16856,6 +17558,13 @@ function projectToolMessage(message) {
   }
   return null;
 }
+function optionalFinite(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return value;
+}
+function optionalString2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function projectFleetMessage(message) {
   const payload = record(message.payload);
   if (!payload) return null;
@@ -16864,7 +17573,15 @@ function projectFleetMessage(message) {
       return {
         kind: "concurrency",
         active: finite(payload["fleetConcurrency"]),
-        maximum: finite(payload["fleetConcurrencyMax"])
+        maximum: finite(payload["fleetConcurrencyMax"]),
+        maxSpawns: optionalFinite(payload["maxSpawns"]),
+        usedSpawns: optionalFinite(payload["usedSpawns"]),
+        remainingSpawns: optionalFinite(payload["remainingSpawns"]),
+        maxSpawnsSource: optionalString2(payload["maxSpawnsSource"]),
+        maxConcurrentSource: optionalString2(payload["maxConcurrentSource"]),
+        effectiveSource: optionalString2(payload["effectiveSource"]),
+        checkpointMaxSpawns: optionalFinite(payload["checkpointMaxSpawns"]),
+        ceilingMismatch: payload["ceilingMismatch"] === true ? true : void 0
       };
     case "client.status_update":
       return { kind: "client-status", status: payload };
@@ -16981,6 +17698,271 @@ function negotiateProtocol(peer) {
 }
 
 // src/server/session-history.ts
+function blockText(block) {
+  if (typeof block === "string") return block;
+  switch (block.type) {
+    case "text":
+      return block.text;
+    case "thinking":
+      return block.thinking;
+    case "tool_use":
+      return `[tool:${block.name}]`;
+    case "tool_result":
+      return block.content;
+    case "image":
+      return "[image]";
+    default: {
+      const _exhaustive = block;
+      void _exhaustive;
+      return "[block]";
+    }
+  }
+}
+function labelForEvent(e) {
+  switch (e.type) {
+    case "session_start":
+      return "Session started";
+    case "session_resumed":
+      return "Session resumed";
+    case "session_forked":
+      return `Forked from ${e.parentSessionId}`;
+    case "user_input": {
+      const content = typeof e.content === "string" ? e.content : Array.isArray(e.content) ? e.content.map(blockText).join("") : "[input]";
+      return `User: ${content.length > 100 ? content.slice(0, 100) + "\u2026" : content}`;
+    }
+    case "llm_request":
+      return "LLM request";
+    case "llm_response":
+      return "LLM response";
+    case "tool_use":
+      return `Tool: ${e.name}`;
+    case "tool_call_start":
+      return `Tool start: ${e.name}`;
+    case "tool_call_end":
+      return `Tool done: ${e.name} (${e.durationMs}ms, ${e.ok === false ? "error" : "ok"})`;
+    case "tool_result":
+      return `Tool result: ${e.id}${e.isError ? " (error)" : ""}`;
+    case "tool_progress":
+      return `Progress: ${e.name} \u2014 ${e.event.type}`;
+    case "compaction":
+      return `Compaction: ${e.before} \u2192 ${e.after} tokens`;
+    case "context_snapshot":
+      return "Context snapshot";
+    case "error":
+      return `Error: ${e.message.length > 100 ? e.message.slice(0, 100) + "\u2026" : e.message}`;
+    case "session_end":
+      return "Session ended";
+    case "message_appended":
+      return `Message appended: ${e.message.role}`;
+    case "message_updated":
+      return "Message updated";
+    case "messages_replaced": {
+      const count = e.messagesOmitted ?? e.messages.length;
+      return `Messages replaced (${e.messagesOmitted ? "~" : ""}${count} msgs)`;
+    }
+    case "message_truncated":
+      return `Message truncated: ${e.before} \u2192 ${e.after}`;
+    case "file_event":
+      return `File ${e.operation}: ${e.filePath} (${e.toolName})`;
+    case "file_snapshot":
+      return `File snapshot at prompt #${e.promptIndex}`;
+    case "file_observation":
+      return `File observation: ${e.path}`;
+    case "rewound":
+      return `Rewound to prompt #${e.toPromptIndex} (${e.revertedFiles.length} files)`;
+    case "mode_changed":
+      return `Mode: ${e.from} \u2192 ${e.to}`;
+    case "task_created":
+      return `Task created: ${e.title}`;
+    case "task_updated":
+      return `Task ${e.taskId}: ${e.status}`;
+    case "task_completed":
+      return `Task done: ${e.title}`;
+    case "task_failed":
+      return `Task failed: ${e.title} \u2014 ${e.error.length > 80 ? e.error.slice(0, 80) + "\u2026" : e.error}`;
+    case "agent_spawned":
+      return `Agent spawned: ${e.role}`;
+    case "agent_stopped":
+      return "Agent stopped";
+    case "agent_error":
+      return `Agent error: ${e.error.length > 80 ? e.error.slice(0, 80) + "\u2026" : e.error}`;
+    case "provider_retry":
+      return `Retry: ${e.description} (attempt ${e.attempt})`;
+    case "provider_error":
+      return `Provider error: ${e.description}`;
+    case "checkpoint":
+      return `Checkpoint at prompt #${e.promptIndex}`;
+    case "in_flight_start":
+      return `In-flight started: ${e.context}`;
+    case "in_flight_end":
+      return `In-flight ended: ${e.reason}`;
+    case "side_effect":
+      return `Side effect: ${e.toolName} (${e.risk})`;
+    case "spec_parsed":
+      return `Spec parsed: ${e.title}`;
+    case "spec_analyzed":
+      return `Spec analyzed: ${e.specId}`;
+    case "skill_activated":
+      return `Skill: ${e.skillName}`;
+    case "skill_deactivated":
+      return `Skill done: ${e.skillName}`;
+    default: {
+      const _exhaustive = e;
+      void _exhaustive;
+      return String(_exhaustive);
+    }
+  }
+}
+function detailForEvent(e) {
+  switch (e.type) {
+    case "session_start":
+      return `${e.model} @ ${e.provider}`;
+    case "session_resumed":
+      return `${e.model} @ ${e.provider}`;
+    case "session_forked":
+      return `parent checkpoint: ${e.parentCheckpointHash.slice(0, 12)}\u2026`;
+    case "llm_request":
+      return `${e.model} \xB7 ${e.messageCount} msgs \xB7 ${e.toolCount ?? "?"} tools`;
+    case "llm_response":
+      return `${e.stopReason} \xB7 ${e.usage.input ?? 0}+${e.usage.output ?? 0} tokens`;
+    case "tool_use":
+      return `id: ${e.id}`;
+    case "tool_call_start":
+      return `id: ${e.id}`;
+    case "tool_call_end":
+      return `${(e.outputBytes ?? e.outputSize ?? 0).toLocaleString()} B \xB7 ${e.outputLines ?? 0} lines`;
+    case "tool_progress":
+      return `${e.event.type}${e.event.text ? `: ${e.event.text}` : ""}`;
+    case "compaction":
+      return `saved ~${Math.max(0, e.before - e.after)} tokens`;
+    case "context_snapshot":
+      return `${e.messages.length} msgs${e.messagesOmitted ? ` (${e.messagesOmitted} omitted)` : ""}`;
+    case "error":
+      return `phase: ${e.phase}`;
+    case "session_end":
+      return `${e.usage.input ?? 0}+${e.usage.output ?? 0} total tokens`;
+    case "message_appended":
+      return `appended ${e.message.role}`;
+    case "message_updated":
+      return `at index ${e.index}`;
+    case "messages_replaced":
+      return `${e.messagesOmitted ?? e.messages.length} total`;
+    case "message_truncated":
+      return `truncated to ${e.after} tokens`;
+    case "mode_changed":
+      return `${e.from} \u2192 ${e.to}`;
+    case "task_created":
+      return `id: ${e.taskId}`;
+    case "task_updated":
+      return `${e.taskId}: ${e.status}`;
+    case "task_completed":
+      return `${e.taskId}`;
+    case "task_failed":
+      return `${e.taskId}: ${e.error}`;
+    case "agent_spawned":
+      return `id: ${e.agentId} (${e.role})`;
+    case "agent_stopped":
+      return `id: ${e.agentId}`;
+    case "agent_error":
+      return `id: ${e.agentId}: ${e.error}`;
+    case "file_event":
+      return `${e.filePath} (${e.toolName})`;
+    case "file_snapshot":
+      return `${e.files.length} files at prompt #${e.promptIndex}`;
+    case "file_observation":
+      return `${e.source === "user" ? "user-saved" : "tool-written"} at ${e.path}`;
+    case "rewound":
+      return `${e.revertedFiles.length} files reverted`;
+    case "in_flight_start":
+      return e.context;
+    case "in_flight_end":
+      return `${e.reason}`;
+    case "side_effect":
+      return `${e.toolName} (${e.risk})${e.outcome ? `: ${e.outcome}` : ""}`;
+    case "provider_retry":
+      return `delay ${e.delayMs}ms${e.status ? ` \xB7 HTTP ${e.status}` : ""}`;
+    case "provider_error":
+      return `${e.retryable ? "retryable" : "fatal"}${e.status ? ` \xB7 HTTP ${e.status}` : ""}`;
+    case "user_input":
+      return typeof e.content === "string" ? `${e.content.length} chars` : `${e.content.length} blocks`;
+    case "tool_result":
+      return `${e.isError ? "error" : "ok"}`;
+    case "checkpoint":
+      return `prompt #${e.promptIndex}`;
+    case "spec_parsed":
+      return `${e.title} (${e.completeness}% complete)`;
+    case "spec_analyzed":
+      return `${e.gaps.length} gaps identified`;
+    case "skill_activated":
+      return `at ${e.skillName}`;
+    case "skill_deactivated":
+      return `at ${e.skillName}`;
+    default: {
+      const _exhaustive = e;
+      void _exhaustive;
+      return "";
+    }
+  }
+}
+function buildInspectPayload(summary, events, fallback) {
+  const inspectEvents = events.map((e) => ({
+    ts: e.ts,
+    type: e.type,
+    label: labelForEvent(e),
+    detail: detailForEvent(e)
+  }));
+  const fileEvents = [];
+  let computedToolCallCount = 0;
+  let computedToolErrorCount = 0;
+  let computedFileChangeCount = 0;
+  let computedCompactionCount = 0;
+  let computedMessageCount = 0;
+  let computedIterationCount = 0;
+  const computedToolBreakdown = {};
+  for (const e of events) {
+    if (e.type === "file_event") {
+      fileEvents.push({
+        operation: e.operation,
+        filePath: e.filePath,
+        toolName: e.toolName,
+        ts: e.ts
+      });
+      computedFileChangeCount++;
+    } else if (e.type === "tool_call_end") {
+      computedToolCallCount++;
+      if (e.ok === false) computedToolErrorCount++;
+      computedToolBreakdown[e.name] = (computedToolBreakdown[e.name] ?? 0) + 1;
+    } else if (e.type === "compaction") {
+      computedCompactionCount++;
+    } else if (e.type === "user_input") {
+      computedMessageCount++;
+    } else if (e.type === "llm_response") {
+      computedIterationCount++;
+    }
+  }
+  const s = summary;
+  return {
+    id: s?.id ?? fallback.id,
+    title: s?.title ?? fallback.title,
+    ...s?.name !== void 0 ? { name: s.name } : {},
+    model: s?.model ?? fallback.model,
+    provider: s?.provider ?? fallback.provider,
+    startedAt: s?.startedAt ?? fallback.startedAt,
+    ...(s?.endedAt ?? fallback.endedAt) !== void 0 ? { endedAt: s?.endedAt ?? fallback.endedAt } : {},
+    tokenTotal: s?.tokenTotal ?? 0,
+    ...s?.outcome !== void 0 ? { outcome: s.outcome } : {},
+    messageCount: s?.messageCount ?? computedMessageCount,
+    iterationCount: s?.iterationCount ?? computedIterationCount,
+    toolCallCount: s?.toolCallCount ?? computedToolCallCount,
+    toolErrorCount: s?.toolErrorCount ?? computedToolErrorCount,
+    fileChangeCount: s?.fileChangeCount ?? computedFileChangeCount,
+    compactionCount: s?.compactionCount ?? computedCompactionCount,
+    toolBreakdown: s?.toolBreakdown ?? computedToolBreakdown,
+    events: inspectEvents,
+    fileEvents,
+    ...s?.lastUserMessage !== void 0 ? { lastUserMessage: s.lastUserMessage } : {}
+  };
+}
 function toSessionHistoryEntry(summary, currentSessionId2) {
   return {
     id: summary.id,
@@ -17255,6 +18237,7 @@ function createSessionHandlers(ctx) {
         tools: ctx.listTools?.() ?? ctx.toolRegistry?.list(),
         baseRevision: typeof payload["baseRevision"] === "string" ? payload["baseRevision"] : "",
         messages: payload["messages"],
+        removals: payload["removals"],
         allowRepair: payload["allowRepair"] === true,
         runActive: ctx.isRunActive?.() === true
       });
@@ -17271,6 +18254,7 @@ function createSessionHandlers(ctx) {
         tools: ctx.listTools?.() ?? ctx.toolRegistry?.list(),
         baseRevision: typeof payload["baseRevision"] === "string" ? payload["baseRevision"] : "",
         messages: payload["messages"],
+        removals: payload["removals"],
         allowRepair: payload["allowRepair"] === true,
         runActive: ctx.isRunActive?.() === true
       });
@@ -17527,6 +18511,47 @@ function createSessionHandlers(ctx) {
       if (!ensureCurrentSession(ws, msg, "session.save")) return;
       result(ws, true, `Session ${ctx.getSession().id} is auto-saved`);
     },
+    inspectSession: async (ws, msg) => {
+      const { id } = msg.payload;
+      if (!id) {
+        sendTo(ws, {
+          type: "session.inspect",
+          payload: { id: "", error: "Session id is required" }
+        });
+        return;
+      }
+      try {
+        const store = ctx.getSessionStore();
+        const data = await store.load(id);
+        let summary;
+        try {
+          const summaries = await store.list(200);
+          summary = summaries.find((s) => s.id === id);
+        } catch {
+          summary = void 0;
+        }
+        const payload = buildInspectPayload(summary, data.events, {
+          id: data.metadata.id,
+          title: data.metadata.title ?? "",
+          model: data.metadata.model ?? "",
+          provider: data.metadata.provider ?? "",
+          startedAt: data.metadata.startedAt,
+          endedAt: data.metadata.endedAt
+        });
+        sendTo(ws, {
+          type: "session.inspect",
+          payload
+        });
+      } catch (err) {
+        sendTo(ws, {
+          type: "session.inspect",
+          payload: {
+            id,
+            error: err instanceof Error ? err.message : String(err)
+          }
+        });
+      }
+    },
     listCheckpoints: async (ws, msg) => {
       if (!ensureCurrentSession(ws, msg, "session.checkpoints")) return;
       try {
@@ -18211,6 +19236,19 @@ async function handleCodebaseIndexServerControl(ws, message, deps2) {
   return true;
 }
 
+// src/server/fallback-choice.ts
+function emitFallbackChoice(events, msg) {
+  const parsed = validateModelFallbackChoicePayload(msg.payload);
+  if (!parsed.ok) return parsed;
+  events?.emit("provider.fallback_choice", {
+    requestId: parsed.value.requestId,
+    ...parsed.value.providerId ? { providerId: parsed.value.providerId } : {},
+    ...parsed.value.model ? { model: parsed.value.model } : {},
+    ...parsed.value.autoSwitch ? { autoSwitch: true } : {}
+  });
+  return { ok: true };
+}
+
 // src/server/agent-roster-routes.ts
 async function handleAgentRosterRoute(ws, msg, handlers) {
   if (!msg.type.startsWith("agent-roster.")) return false;
@@ -18375,13 +19413,17 @@ async function handleProviderRoute(ws, msg, routes) {
     case "model.refine":
       await routes.refineModel(ws, msg);
       return true;
+    case "model.fallback_choice":
+      await routes.fallbackChoice(ws, msg);
+      return true;
     case "key.add":
     case "key.update": {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const label = payload ? requiredString(payload, "label") : null;
       const apiKey = payload ? requiredString(payload, "apiKey") : null;
-      if (!providerId || !label || !apiKey) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !label || !apiKey)
+        return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleKeyUpsert(ws, providerId, label, apiKey);
       return true;
     }
@@ -18389,7 +19431,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const label = payload ? requiredString(payload, "label") : null;
-      if (!providerId || !label) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !label)
+        return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleKeyDelete(ws, providerId, label);
       return true;
     }
@@ -18397,7 +19440,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const label = payload ? requiredString(payload, "label") : null;
-      if (!providerId || !label) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !label)
+        return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleKeySetActive(ws, providerId, label);
       return true;
     }
@@ -18409,11 +19453,11 @@ async function handleProviderRoute(ws, msg, routes) {
       const apiKey = payload?.["apiKey"];
       const models = payload ? optionalStringArray(payload, "models") : null;
       const customModels = payload ? optionalCustomModels(payload) : null;
-      if (!id || !family) return invalidPayload(ws, msg.type);
+      if (!id || !SAFE_CONFIG_KEY.test(id) || !family) return invalidPayload(ws, msg.type);
       if (baseUrl !== void 0 && typeof baseUrl !== "string") return invalidPayload(ws, msg.type);
       if (apiKey !== void 0 && typeof apiKey !== "string") return invalidPayload(ws, msg.type);
       if (models === null || customModels === null) return invalidPayload(ws, msg.type);
-      await routes.providerHandlers.handleProviderAdd(ws, {
+      const added = await routes.providerHandlers.handleProviderAdd(ws, {
         id,
         family,
         baseUrl,
@@ -18421,20 +19465,22 @@ async function handleProviderRoute(ws, msg, routes) {
         models,
         customModels
       });
-      await routes.adoptDefaultProviderIfUnset(id);
+      if (added) {
+        void routes.adoptDefaultProviderIfUnset(id).catch(() => void 0);
+      }
       return true;
     }
     case "provider.remove": {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
-      if (!providerId) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId)) return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleProviderRemove(ws, providerId);
       return true;
     }
     case "provider.clear_models": {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
-      if (!providerId) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId)) return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleProviderClearModels(ws, providerId);
       return true;
     }
@@ -18448,7 +19494,7 @@ async function handleProviderRoute(ws, msg, routes) {
       const customModelRaw = payload["customModel"];
       if (!isRecord4(customModelRaw)) return invalidPayload(ws, msg.type);
       const cm = optionalCustomModels({ customModels: { [modelId]: customModelRaw } });
-      if (!cm || !cm[modelId]) return invalidPayload(ws, msg.type);
+      if (!cm?.[modelId]) return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleCustomModelSet(ws, providerId, modelId, cm[modelId]);
       return true;
     }
@@ -18466,7 +19512,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const previousModels = payload ? optionalStringArray(payload, "previousModels") : null;
-      if (!providerId || !previousModels) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !previousModels)
+        return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleProviderUndoClear(ws, providerId, previousModels);
       return true;
     }
@@ -18476,7 +19523,7 @@ async function handleProviderRoute(ws, msg, routes) {
       const envVars = payload ? optionalStringArray(payload, "envVars") : null;
       const models = payload ? optionalStringArray(payload, "models") : null;
       const customModels = payload ? optionalCustomModels(payload) : null;
-      if (!payload || !id || envVars === null || models === null || customModels === null)
+      if (!payload || !id || !SAFE_CONFIG_KEY.test(id) || envVars === null || models === null || customModels === null)
         return invalidPayload(ws, msg.type);
       for (const key of ["family", "baseUrl"]) {
         if (payload[key] !== void 0 && typeof payload[key] !== "string")
@@ -18496,7 +19543,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const timeoutMs = payload ? optionalNumber(payload, "timeoutMs") : null;
-      if (!providerId || timeoutMs === null) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || timeoutMs === null)
+        return invalidPayload(ws, msg.type);
       await routes.providerHandlers.handleProviderProbe(ws, providerId, timeoutMs);
       return true;
     }
@@ -18505,7 +19553,7 @@ async function handleProviderRoute(ws, msg, routes) {
       const kind = oauthKind(payload);
       const providerId = payload?.["providerId"];
       if (!kind) return invalidPayload(ws, msg.type);
-      if (providerId !== void 0 && typeof providerId !== "string") {
+      if (providerId !== void 0 && (typeof providerId !== "string" || !SAFE_CONFIG_KEY.test(providerId))) {
         return invalidPayload(ws, msg.type);
       }
       await routes.providerHandlers.handleOAuthStart(ws, kind, providerId);
@@ -18544,7 +19592,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const model = payload ? requiredString(payload, "model") : null;
-      if (!providerId || !model) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !model)
+        return invalidPayload(ws, msg.type);
       const released = routes.statusTracker.retryNow(providerId, model);
       sendResult2(
         ws,
@@ -18561,7 +19610,8 @@ async function handleProviderRoute(ws, msg, routes) {
       const payload = asPayloadRecord(msg);
       const providerId = payload ? requiredString(payload, "providerId") : null;
       const model = payload ? requiredString(payload, "model") : null;
-      if (!providerId || !model) return invalidPayload(ws, msg.type);
+      if (!providerId || !SAFE_CONFIG_KEY.test(providerId) || !model)
+        return invalidPayload(ws, msg.type);
       routes.statusTracker.clear(providerId, model);
       sendResult2(ws, true, `Cleared tracking for ${providerId}/${model}.`);
       return true;
@@ -18642,6 +19692,9 @@ async function handleSessionRoute(ws, msg, handlers) {
     case "session.save":
       await handlers.saveSession(ws, msg);
       return true;
+    case "session.inspect":
+      await handlers.inspectSession(ws, msg);
+      return true;
     case "session.checkpoints":
       await handlers.listCheckpoints(ws, msg);
       return true;
@@ -18916,8 +19969,10 @@ function createEmbeddedMessageRouter(deps2) {
   };
   const mcp = {
     list: (ws, msg) => handleMcpList(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
-    add: (ws, msg) => handleMcpAdd(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
-    update: (ws, msg) => handleMcpUpdate(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
+    // add/update are the spawn-capable pair — they take a `command`/`args`
+    // from the wire and start it. They go past the trust boundary (M1).
+    add: (ws, msg) => handleMcpAdd(ws, msg, opts.profileConfigPath, opts.mcpRegistry, deps2.trustBoundary),
+    update: (ws, msg) => handleMcpUpdate(ws, msg, opts.profileConfigPath, opts.mcpRegistry, deps2.trustBoundary),
     remove: (ws, msg) => handleMcpRemove(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
     enable: (ws, msg) => handleMcpEnable(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
     disable: (ws, msg) => handleMcpDisable(ws, msg, opts.profileConfigPath, opts.mcpRegistry),
@@ -19004,6 +20059,15 @@ function createEmbeddedMessageRouter(deps2) {
     searchProviderModels: (ws, query, limit) => providerOperations.handleProviderModelsSearch(ws, query, limit),
     switchModel: (ws, msg) => modelOperations.switchModel(ws, msg.payload),
     refineModel: (ws, msg) => modelOperations.refineModel(ws, msg.payload),
+    fallbackChoice: async (ws, msg) => {
+      const result = emitFallbackChoice(deps2.sessionCtx.opts.events, msg);
+      if (!result.ok) {
+        send2(ws, {
+          type: "error",
+          payload: { phase: "invalid_request", message: result.message }
+        });
+      }
+    },
     adoptDefaultProviderIfUnset: providerOperations.adoptDefaultProviderIfUnset,
     providerHandlers: providerOperations,
     statusTracker: deps2.statusTracker
@@ -19297,17 +20361,12 @@ function createProviderStore(deps2) {
       cfg.activeKey = active.label;
     }
   }
-  function maskedKey2(key) {
-    if (!key) return "\u2014";
-    if (key.length <= 8) return "\u2022".repeat(key.length);
-    return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
-  }
   return {
     load: loadSavedProviders2,
     save: saveProviders2,
     normalizeKeys: normalizeKeys2,
     writeKeysBack: writeKeysBack2,
-    maskedKey: maskedKey2
+    maskedKey
   };
 }
 
@@ -20974,7 +22033,8 @@ function setupEvents(deps2) {
         attempt: e.attempt,
         delayMs: e.delayMs,
         status: e.status,
-        description: e.description
+        description: e.description,
+        ...e.errorBody ? { errorBody: e.errorBody } : {}
       })
     });
     appendForCurrentSession(e.sessionId, {
@@ -20984,7 +22044,8 @@ function setupEvents(deps2) {
       attempt: e.attempt,
       delayMs: e.delayMs,
       status: e.status,
-      description: e.description
+      description: e.description,
+      ...e.errorBody ? { errorBody: e.errorBody } : {}
     });
   });
   on("provider.status_changed", (e) => {
@@ -21024,7 +22085,8 @@ function setupEvents(deps2) {
         providerId: e.providerId,
         status: e.status,
         description: e.description,
-        retryable: e.retryable
+        retryable: e.retryable,
+        ...e.errorBody ? { errorBody: e.errorBody } : {}
       })
     });
     appendForCurrentSession(e.sessionId, {
@@ -21033,7 +22095,8 @@ function setupEvents(deps2) {
       providerId: e.providerId,
       status: e.status,
       description: e.description,
-      retryable: e.retryable
+      retryable: e.retryable,
+      ...e.errorBody ? { errorBody: e.errorBody } : {}
     });
   });
   on("provider.fallback", (e) => {
@@ -21044,7 +22107,22 @@ function setupEvents(deps2) {
         from: e.from,
         to: e.to,
         status: e.status,
-        providerSwitched: e.providerSwitched
+        providerSwitched: e.providerSwitched,
+        ...e.requestId ? { requestId: e.requestId } : {}
+      })
+    });
+  });
+  on("provider.fallback_pending", (e) => {
+    broadcast2(clients, {
+      type: "provider.fallback_pending",
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        from: e.from,
+        status: e.status,
+        candidates: e.candidates,
+        autoSwitchSeconds: e.autoSwitchSeconds,
+        requestId: e.requestId,
+        timestamp: e.timestamp
       })
     });
   });
@@ -21129,6 +22207,15 @@ function setupEvents(deps2) {
         type: "mailbox.agent_registered",
         payload
       });
+    }),
+    // Deregistration (subagent retirement) must reach the browser too —
+    // otherwise dead agents linger in the client roster until an unrelated
+    // refresh. Emitted by sqlite-mailbox.deregisterAgent with { agentId }.
+    events.onPattern("mailbox.agent_deregistered", (_e, payload) => {
+      broadcast2(clients, {
+        type: "mailbox.agent_deregistered",
+        payload
+      });
     })
   );
   const forwardSubagent = (kind, payload) => broadcast2(clients, { type: "subagent.event", payload: sessionPayload2({ kind, ...payload }) });
@@ -23413,29 +24500,10 @@ import { attachSessionKanbanMirror, hydrateSessionKanban } from "@wrongstack/too
 // src/server/model-auto-discovery.ts
 import * as fs21 from "node:fs/promises";
 import * as path29 from "node:path";
-import { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from "@wrongstack/providers";
+import { discoverOpenAICompatibleModels, resolveDiscoveryTargets } from "@wrongstack/providers";
 function isOverlayRegistry(value) {
   return !!value && typeof value === "object" && typeof value.mergeOverlay === "function";
 }
-function resolveKey(cfg) {
-  if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
-    const active = cfg.activeKey ? cfg.apiKeys.find((key) => key.label === cfg.activeKey) : void 0;
-    return (active ?? cfg.apiKeys[0])?.apiKey;
-  }
-  return cfg.apiKey && cfg.apiKey.length > 0 ? cfg.apiKey : void 0;
-}
-function eligibleProviders(config) {
-  const out = [];
-  for (const [id, cfg] of Object.entries(config.providers ?? {})) {
-    const preset = COMPATIBLE_PRESETS[id];
-    const enabled = cfg.autoDiscoverModels ?? preset?.autoDiscover ?? false;
-    if (!enabled) continue;
-    const baseUrl = cfg.baseUrl ?? preset?.defaultBaseUrl;
-    if (!baseUrl) continue;
-    out.push({ id, cfg, baseUrl, apiKey: resolveKey(cfg) });
-  }
-  return out;
-}
 async function readCache(file) {
   try {
     return JSON.parse(await fs21.readFile(file, "utf8"));
@@ -23446,14 +24514,13 @@ async function readCache(file) {
 async function discoverAndMergeWebuiProviders(opts) {
   const registry = opts.registry;
   if (!isOverlayRegistry(registry)) return;
-  const targets = eligibleProviders(opts.config);
+  const targets = resolveDiscoveryTargets(opts.config);
   if (targets.length === 0) return;
   const cacheFile = path29.join(opts.cacheDir, "discovered-models-cache.json");
   const cache2 = await readCache(cacheFile);
   let cacheDirty = false;
   await Promise.all(
-    targets.map(async ({ id, cfg, baseUrl, apiKey }) => {
-      const cacheKey = `${id}\0${baseUrl}`;
+    targets.map(async ({ id, cfg, baseUrl, apiKey, cacheKey }) => {
       const provider = await discoverOpenAICompatibleModels(id, {
         baseUrl,
         apiKey,
@@ -23819,15 +24886,6 @@ async function createPreContextServices(input) {
       logger.warn(`models.dev refresh failed (${toErrorMessage12(err)}); using cached catalog`);
     }
   }
-  try {
-    await installCatalogModelOutputLimits({
-      registry: modelsRegistry,
-      getConfig: () => config,
-      log: (message) => logger.debug(message)
-    });
-  } catch (err) {
-    logger.debug(`model output-limit index skipped: ${toErrorMessage12(err)}`);
-  }
   try {
     await discoverAndMergeWebuiProviders({
       config,
@@ -23838,6 +24896,15 @@ async function createPreContextServices(input) {
   } catch (err) {
     logger.debug(`provider auto-discovery skipped: ${toErrorMessage12(err)}`);
   }
+  try {
+    await installCatalogModelOutputLimits({
+      registry: modelsRegistry,
+      getConfig: () => config,
+      log: (message) => logger.debug(message)
+    });
+  } catch (err) {
+    logger.debug(`model output-limit index skipped: ${toErrorMessage12(err)}`);
+  }
   const events = opts.services?.events ?? new EventBus();
   events.setLogger(logger);
   const container = createDefaultContainer({ config, wpaths, logger, modelsRegistry, events });
@@ -24110,7 +25177,7 @@ import { makeProviderFromConfig as makeProviderFromConfig4, withCatalogCapabilit
 
 // src/server/mode-handlers.ts
 import { DefaultSystemPromptBuilder as DefaultSystemPromptBuilder2 } from "@wrongstack/core/agent";
-import { resolveWstackPaths as resolveWstackPaths5 } from "@wrongstack/core/utils";
+import { resolveWstackPaths as resolveWstackPaths6 } from "@wrongstack/core/utils";
 function createModeHandlers(context) {
   return createModeRouteHandlers({
     modeStore: context.modeStore,
@@ -24119,7 +25186,7 @@ function createModeHandlers(context) {
     send,
     afterSwitch: async (id) => {
       const modePrompt = id === "default" ? "" : (await context.modeStore.getMode(id))?.prompt ?? "";
-      const paths = resolveWstackPaths5({
+      const paths = resolveWstackPaths6({
         projectRoot: context.projectRoot,
         globalRoot: context.globalRoot
       });
@@ -24224,7 +25291,16 @@ function buildRoutes(state, deps2, cb) {
     refineModel: (ws, msg) => modelOperations.refineModel(
       ws,
       msg.payload
-    )
+    ),
+    fallbackChoice: async (ws, msg) => {
+      const result = emitFallbackChoice(deps2.events, msg);
+      if (!result.ok) {
+        send(ws, {
+          type: "error",
+          payload: { phase: "invalid_request", message: result.message }
+        });
+      }
+    }
   };
   const sessionRoutes = createSessionHandlers({
     config: state.getConfig(),
@@ -24402,8 +25478,10 @@ function buildRoutes(state, deps2, cb) {
   });
   const mcpRoutes = {
     list: (ws, msg) => handleMcpList(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
-    add: (ws, msg) => handleMcpAdd(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
-    update: (ws, msg) => handleMcpUpdate(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
+    // add/update are the spawn-capable pair — they take a `command`/`args`
+    // from the wire and start it. They go past the trust boundary (M1).
+    add: (ws, msg) => handleMcpAdd(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry, deps2.trustBoundary),
+    update: (ws, msg) => handleMcpUpdate(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry, deps2.trustBoundary),
     remove: (ws, msg) => handleMcpRemove(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
     enable: (ws, msg) => handleMcpEnable(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
     disable: (ws, msg) => handleMcpDisable(ws, msg, deps2.profileConfigPath, deps2.mcpRegistry),
@@ -24479,7 +25557,10 @@ async function resolvePorts(opts) {
   const surface = opts.surface ?? "webui";
   const surfaceDefaults = surface === "simpleui" ? { http: 3466 } : { http: 3456 };
   const wsHost = opts.wsHost ?? process.env["WEBUI_HOST"] ?? process.env["WS_HOST"] ?? "127.0.0.1";
-  const requestedHttpPort = opts.httpPort ?? opts.webuiPort ?? opts.port ?? Number.parseInt(process.env["WEBUI_PORT"] ?? process.env["PORT"] ?? String(surfaceDefaults.http), 10);
+  const requestedHttpPort = opts.httpPort ?? opts.webuiPort ?? opts.port ?? Number.parseInt(
+    process.env["WEBUI_PORT"] ?? process.env["PORT"] ?? String(surfaceDefaults.http),
+    10
+  );
   const publicUrl = opts.publicUrl ?? process.env["WEBUI_PUBLIC_URL"];
   const publicWsUrl = opts.publicWsUrl ?? process.env["WEBUI_PUBLIC_WS_URL"];
   const requireToken = opts.requireToken ?? envFlag("WEBUI_REQUIRE_TOKEN");
@@ -24488,7 +25569,16 @@ async function resolvePorts(opts) {
   if (!strictPort) {
     httpPort = await findFreePort(wsHost, requestedHttpPort);
     if (httpPort !== requestedHttpPort) {
-      console.warn(JSON.stringify({ level: "warn", event: "webui.port_reassigned", protocol: "HTTP", requested: requestedHttpPort, assigned: httpPort, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "webui.port_reassigned",
+          protocol: "HTTP",
+          requested: requestedHttpPort,
+          assigned: httpPort,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     }
   }
   return { wsHost, httpPort, publicUrl, publicWsUrl, requireToken };
@@ -24563,7 +25653,10 @@ function createWsServers(httpServer, ports, accessToken) {
     expectedToken: wsToken,
     requireToken: ports.requireToken,
     allowedHostnames: publicHostnames,
-    allowBrowserUrlToken: Boolean(ports.publicWsUrl)
+    allowBrowserUrlToken: Boolean(ports.publicWsUrl),
+    // WS-003 opt-out for the Vite dev loop only (app and WS server cannot
+    // share a port). Off unless explicitly requested — see ws-auth.ts.
+    allowCrossPortLoopbackCookie: process.env["WRONGSTACK_WEBUI_DEV_CROSS_PORT_WS"] === "1"
   });
   const WS_MAX_PAYLOAD = 20 * 1024 * 1024;
   const wssPrimary = new WebSocketServer({
@@ -24594,21 +25687,49 @@ function armEvents(wssPrimary, wssSecondary, wsHost, httpPort, setupInput, watch
     if (eventsArmed) return;
     eventsArmed = true;
     console.log(`[WebUI] Backend ready (${label})`);
-    disposeEvents = setupEvents({ ...setupInput, watcherMetrics, onFleetBroadcaster: (fn) => {
-      fleetBroadcast = fn;
-    } });
+    disposeEvents = setupEvents({
+      ...setupInput,
+      watcherMetrics,
+      onFleetBroadcaster: (fn) => {
+        fleetBroadcast = fn;
+      }
+    });
   };
   wssPrimary.on("listening", () => arm(`${wsHost}:${httpPort}`));
   wssPrimary.on("error", (err) => {
-    console.error(JSON.stringify({ level: "error", event: "webui.ws_server_error", host: wsHost, message: toErrorMessage13(err), timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "webui.ws_server_error",
+        host: wsHost,
+        message: toErrorMessage13(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
   });
   if (wssSecondary) {
     wssSecondary.on("listening", () => arm(`::1:${httpPort}`));
     wssSecondary.on("error", (err) => {
       if (err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL") {
-        console.warn(JSON.stringify({ level: "warn", event: "webui.ipv6_unavailable", code: err.code, message: err.message, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "webui.ipv6_unavailable",
+            code: err.code,
+            message: err.message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
       } else {
-        console.error(JSON.stringify({ level: "error", event: "webui.ws_server_error", host: "::1", message: err.message, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "webui.ws_server_error",
+            host: "::1",
+            message: err.message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
       }
     });
   }
@@ -24629,6 +25750,7 @@ function resolveWebuiDistDir(fromUrl, explicitDistDir) {
   }
 }
 function startHttpServer(opts) {
+  const intakeService = opts.intakeService ?? createProjectIntakeService({ projectRoot: opts.projectRoot, globalRoot: opts.globalRoot });
   const httpServer = createHttpServer({
     host: opts.wsHost,
     port: opts.httpPort,
@@ -24642,7 +25764,8 @@ function startHttpServer(opts) {
     onTechStackEvent: opts.onTechStackEvent,
     getLlm: opts.getLlm,
     executePackageOperation: opts.executePackageOperation,
-    projectRoot: opts.projectRoot
+    projectRoot: opts.projectRoot,
+    intakeService
   });
   return httpServer;
 }