@wrongstack/webui-server 0.298.3 → 0.299.0

package/dist/server/entry.js

@@ -7497,7 +7497,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
   }
   try {
     const { SessionRegistry, DefaultSessionStore: DefaultSessionStore3, 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) {
@@ -7505,7 +7505,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 DefaultSessionStore3({ dir: paths.projectSessions });
     const reader = new DefaultSessionReader2({ store });
     const rawEntries = [];
@@ -7586,7 +7586,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox5, 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) {
@@ -7594,7 +7594,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 = getSharedProjectMailbox5(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.send({ from, to, type, subject, body: text, priority });
@@ -7614,7 +7614,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox5, 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) {
@@ -7622,7 +7622,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 = getSharedProjectMailbox5(paths.projectDir);
     const leaderAddr = `leader@${mailboxSessionTag2(sessionId)}`;
     const [inbound, outbound] = await Promise.all([
@@ -7674,7 +7674,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox5, 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) {
@@ -7682,7 +7682,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 = getSharedProjectMailbox5(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.sendRuntimeControl({
@@ -7723,7 +7723,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
   try {
     const { SessionRegistry } = await import("@wrongstack/core/storage");
     const { getSharedProjectMailbox: getSharedProjectMailbox5, 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;
@@ -7735,7 +7735,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 = getSharedProjectMailbox5(dir);
@@ -7769,6 +7769,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((resolve15) => {
+    let data = "";
+    let failed = false;
+    const fail2 = (message) => {
+      if (failed) return;
+      failed = true;
+      sendJson2(res, 400, { error: { code: "INVALID_BODY", message } });
+      resolve15(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 {
+        resolve15(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 record = await service.getIntake(intakeId, intakeContext(""));
+  if (!record) {
+    sendNotFound(res, intakeId);
+    return null;
+  }
+  return record;
+}
+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 record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    sendJson2(res, 200, record);
+  } 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 record = await discoverIntake(res, service, intakeId);
+    if (!record) 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(record.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 record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    const updated = await service.addAnswer(
+      intakeId,
+      body,
+      intakeContext(record.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 record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    const focus = Array.isArray(body["focus"]) ? body["focus"] : void 0;
+    const suggestions = await service.generateSuggestions(
+      intakeId,
+      intakeContext(record.projectId),
+      focus
+    );
+    sendJson2(res, 200, { suggestions });
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeSubmit(res, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    const result = await service.submitIntake(intakeId, intakeContext(record.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 record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    const reason = typeof body["reason"] === "string" ? body["reason"] : void 0;
+    const updated = await service.cancelIntake(intakeId, intakeContext(record.projectId), reason);
+    sendJson2(res, 200, updated);
+  } catch (error2) {
+    sendIntakeError(res, error2);
+  }
+}
+async function handleRequirementIntakeArchive(res, service, intakeId) {
+  if (!serviceOr503(res, service)) return;
+  try {
+    const record = await discoverIntake(res, service, intakeId);
+    if (!record) return;
+    const updated = await service.archiveIntake(intakeId, intakeContext(record.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";
@@ -7974,7 +8214,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));
 }
@@ -7989,13 +8229,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)
     });
@@ -8006,7 +8246,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;
@@ -8017,7 +8257,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,
@@ -8063,24 +8303,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;
@@ -8097,9 +8337,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();
@@ -8108,15 +8348,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) {
@@ -8127,30 +8367,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;
@@ -8163,16 +8403,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);
@@ -8187,14 +8427,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;
@@ -8215,7 +8458,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 === "[::]";
@@ -8591,6 +8834,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" });
@@ -8786,17 +9111,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/")) {
@@ -12272,6 +12605,25 @@ async function findFreePort(host, startPort, opts = {}) {
   });
 }
 
+// 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/network-info.ts
 import * as os2 from "node:os";
 function isTailscaleIPv4(addr) {
@@ -12327,7 +12679,21 @@ function formatExternalAccessUrls(opts) {
 }
 
 // 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 } });
 }
@@ -12367,7 +12733,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) {
@@ -12391,7 +12757,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." }
       }
@@ -12401,7 +12767,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)}`
       }
@@ -13166,7 +13532,7 @@ async function handleProcessRoute(ws, msg, handlers) {
 import * as fs14 from "node:fs/promises";
 import * as path16 from "node:path";
 import { DefaultSessionStore } from "@wrongstack/core/storage";
-import { resolveWstackPaths as resolveWstackPaths4 } from "@wrongstack/core/utils";
+import { resolveWstackPaths as resolveWstackPaths5 } from "@wrongstack/core/utils";
 function createProjectHandlers(ctx) {
   const sendTo = (ws, message) => {
     if (ctx.sendMessage) ctx.sendMessage(ws, message);
@@ -13284,7 +13650,7 @@ function createProjectHandlers(ctx) {
           });
           return;
         }
-        const paths = resolveWstackPaths4({
+        const paths = resolveWstackPaths5({
           projectRoot: resolved,
           globalRoot: ctx.wpaths.globalRoot
         });
@@ -13295,7 +13661,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
         });
@@ -14218,6 +14584,7 @@ var CLIENT_CONVERSATION_MESSAGE_TYPES = [
   "modes.list",
   "session.checkpoints",
   "session.delete",
+  "session.inspect",
   "session.new",
   "session.rename",
   "session.resume",
@@ -14481,6 +14848,7 @@ var SERVER_CONVERSATION_MESSAGE_TYPES = [
   "session.checkpoints",
   "session.damaged",
   "session.end",
+  "session.inspect",
   "session.rewound",
   "session.start",
   "session.stats",
@@ -14839,6 +15207,271 @@ function protocolAdvertisement() {
 }
 
 // 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,
@@ -15385,6 +16018,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 {
@@ -16144,7 +16818,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;
     }
@@ -16338,6 +17012,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;
@@ -18210,7 +18887,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, {
@@ -18220,7 +18898,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) => {
@@ -18260,7 +18939,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, {
@@ -18269,7 +18949,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) => {
@@ -21346,7 +22027,7 @@ import { makeProviderFromConfig as makeProviderFromConfig2, 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,
@@ -21355,7 +22036,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
       });
@@ -21715,7 +22396,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");
@@ -21724,7 +22408,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 };
@@ -21830,21 +22523,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: toErrorMessage12(err), timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "webui.ws_server_error",
+        host: wsHost,
+        message: toErrorMessage12(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()
+          })
+        );
       }
     });
   }
@@ -21865,6 +22586,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,
@@ -21878,7 +22600,8 @@ function startHttpServer(opts) {
     onTechStackEvent: opts.onTechStackEvent,
     getLlm: opts.getLlm,
     executePackageOperation: opts.executePackageOperation,
-    projectRoot: opts.projectRoot
+    projectRoot: opts.projectRoot,
+    intakeService
   });
   return httpServer;
 }