@wrongstack/webui 0.272.2 → 0.273.1

package/dist/server/entry.js

@@ -8,7 +8,10 @@ function isRecord(value) {
 }
 function validateModelSwitchPayload(payload) {
   if (!isRecord(payload)) {
-    return { ok: false, message: "model.switch payload must be an object with string provider and model" };
+    return {
+      ok: false,
+      message: "model.switch payload must be an object with string provider and model"
+    };
   }
   const provider = payload["provider"];
   const model = payload["model"];
@@ -30,13 +33,22 @@ function validateMailboxMessagesPayload(payload) {
   const agentId = payload["agentId"];
   const unreadOnly = payload["unreadOnly"];
   if (limit !== void 0 && (typeof limit !== "number" || !Number.isFinite(limit) || limit < 1)) {
-    return { ok: false, message: "mailbox.messages payload.limit must be a positive number when provided" };
+    return {
+      ok: false,
+      message: "mailbox.messages payload.limit must be a positive number when provided"
+    };
   }
   if (agentId !== void 0 && typeof agentId !== "string") {
-    return { ok: false, message: "mailbox.messages payload.agentId must be a string when provided" };
+    return {
+      ok: false,
+      message: "mailbox.messages payload.agentId must be a string when provided"
+    };
   }
   if (unreadOnly !== void 0 && typeof unreadOnly !== "boolean") {
-    return { ok: false, message: "mailbox.messages payload.unreadOnly must be a boolean when provided" };
+    return {
+      ok: false,
+      message: "mailbox.messages payload.unreadOnly must be a boolean when provided"
+    };
   }
   return { ok: true, value: { limit, agentId, unreadOnly } };
 }
@@ -47,7 +59,10 @@ function validateMailboxAgentsPayload(payload) {
   }
   const onlineOnly = payload["onlineOnly"];
   if (onlineOnly !== void 0 && typeof onlineOnly !== "boolean") {
-    return { ok: false, message: "mailbox.agents payload.onlineOnly must be a boolean when provided" };
+    return {
+      ok: false,
+      message: "mailbox.agents payload.onlineOnly must be a boolean when provided"
+    };
   }
   return { ok: true, value: { onlineOnly } };
 }
@@ -59,10 +74,16 @@ function validateMailboxPurgePayload(payload) {
   const completedMaxAgeMs = payload["completedMaxAgeMs"];
   const incompleteMaxAgeMs = payload["incompleteMaxAgeMs"];
   if (completedMaxAgeMs !== void 0 && (typeof completedMaxAgeMs !== "number" || !Number.isFinite(completedMaxAgeMs) || completedMaxAgeMs < 0)) {
-    return { ok: false, message: "mailbox.purge payload.completedMaxAgeMs must be a non-negative number when provided" };
+    return {
+      ok: false,
+      message: "mailbox.purge payload.completedMaxAgeMs must be a non-negative number when provided"
+    };
   }
   if (incompleteMaxAgeMs !== void 0 && (typeof incompleteMaxAgeMs !== "number" || !Number.isFinite(incompleteMaxAgeMs) || incompleteMaxAgeMs < 0)) {
-    return { ok: false, message: "mailbox.purge payload.incompleteMaxAgeMs must be a non-negative number when provided" };
+    return {
+      ok: false,
+      message: "mailbox.purge payload.incompleteMaxAgeMs must be a non-negative number when provided"
+    };
   }
   return { ok: true, value: { completedMaxAgeMs, incompleteMaxAgeMs } };
 }
@@ -73,7 +94,10 @@ function validateBrainRiskPayload(payload) {
   }
   const level = payload["level"];
   if (typeof level !== "string" || !BRAIN_RISK_VALUES.has(level)) {
-    return { ok: false, message: "brain.risk payload.level must be one of off, low, medium, high, all" };
+    return {
+      ok: false,
+      message: "brain.risk payload.level must be one of off, low, medium, high, all"
+    };
   }
   return { ok: true, value: { level } };
 }
@@ -99,7 +123,10 @@ function validateAutonomySwitchPayload(payload) {
 }
 function validatePlanTemplateUsePayload(payload) {
   if (!isRecord(payload)) {
-    return { ok: false, message: "plan.template_use payload must be an object with string template" };
+    return {
+      ok: false,
+      message: "plan.template_use payload must be an object with string template"
+    };
   }
   const template = payload["template"];
   if (typeof template !== "string" || template.trim().length === 0) {
@@ -114,7 +141,15 @@ var ENHANCE_LANGUAGE_VALUES = /* @__PURE__ */ new Set(["original", "english"]);
 var LOG_LEVEL_VALUES = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
 var AUDIT_LEVEL_VALUES = /* @__PURE__ */ new Set(["minimal", "standard", "full"]);
 var REASONING_MODE_VALUES = /* @__PURE__ */ new Set(["auto", "on", "off"]);
-var REASONING_EFFORT_VALUES = /* @__PURE__ */ new Set(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var REASONING_EFFORT_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
 var CACHE_TTL_VALUES = /* @__PURE__ */ new Set(["default", "5m", "1h"]);
 var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   "yolo",
@@ -135,8 +170,10 @@ var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   "tgDelegate",
   "reasoningPreserve",
   "hqEnabled",
-  "hqRawContent"
+  "hqRawContent",
+  "fallbackAuto"
 ]);
+var STRING_ARRAY_PREF_KEYS = /* @__PURE__ */ new Set(["fallbackModels"]);
 var NUMBER_PREF_KEYS = /* @__PURE__ */ new Set([
   "autonomyDelayMs",
   "autoProceedMaxIterations",
@@ -168,6 +205,9 @@ function validatePreferenceValue(key, value) {
   if (STRING_PREF_KEYS.has(key)) {
     return typeof value === "string" ? null : `prefs.update payload.${key} must be a string`;
   }
+  if (STRING_ARRAY_PREF_KEYS.has(key)) {
+    return Array.isArray(value) && value.every((v) => typeof v === "string") ? null : `prefs.update payload.${key} must be an array of strings`;
+  }
   const allowed = ENUM_PREF_KEYS[key];
   if (allowed) {
     return typeof value === "string" && allowed.has(value) ? null : `prefs.update payload.${key} must be one of: ${Array.from(allowed).join(", ")}`;
@@ -288,16 +328,25 @@ function validateContextModeCreatePayload(payload) {
     return { ok: false, message: "context.mode.create payload.description must be a string" };
   }
   if (!isRecord(thresholds)) {
-    return { ok: false, message: "context.mode.create payload.thresholds must be an object with warn/soft/hard numbers" };
+    return {
+      ok: false,
+      message: "context.mode.create payload.thresholds must be an object with warn/soft/hard numbers"
+    };
   }
   if (!isFiniteNumber(thresholds["warn"]) || !isFiniteNumber(thresholds["soft"]) || !isFiniteNumber(thresholds["hard"])) {
-    return { ok: false, message: "context.mode.create payload.thresholds.warn/soft/hard must be finite numbers" };
+    return {
+      ok: false,
+      message: "context.mode.create payload.thresholds.warn/soft/hard must be finite numbers"
+    };
   }
   if (!isFiniteNumber(preserveK)) {
     return { ok: false, message: "context.mode.create payload.preserveK must be a finite number" };
   }
   if (!isFiniteNumber(eliseThreshold)) {
-    return { ok: false, message: "context.mode.create payload.eliseThreshold must be a finite number" };
+    return {
+      ok: false,
+      message: "context.mode.create payload.eliseThreshold must be a finite number"
+    };
   }
   return {
     ok: true,
@@ -321,22 +370,34 @@ function validateContextModeUpdatePayload(payload) {
   }
   const name2 = payload["name"];
   if (name2 !== void 0 && typeof name2 !== "string") {
-    return { ok: false, message: "context.mode.update payload.name must be a string when provided" };
+    return {
+      ok: false,
+      message: "context.mode.update payload.name must be a string when provided"
+    };
   }
   const description = payload["description"];
   if (description !== void 0 && typeof description !== "string") {
-    return { ok: false, message: "context.mode.update payload.description must be a string when provided" };
+    return {
+      ok: false,
+      message: "context.mode.update payload.description must be a string when provided"
+    };
   }
   const thresholds = payload["thresholds"];
   let validatedThresholds;
   if (thresholds !== void 0) {
     if (!isRecord(thresholds)) {
-      return { ok: false, message: "context.mode.update payload.thresholds must be an object when provided" };
+      return {
+        ok: false,
+        message: "context.mode.update payload.thresholds must be an object when provided"
+      };
     }
     for (const key of ["warn", "soft", "hard"]) {
       const val = thresholds[key];
       if (val !== void 0 && !isFiniteNumber(val)) {
-        return { ok: false, message: `context.mode.update payload.thresholds.${key} must be a finite number when provided` };
+        return {
+          ok: false,
+          message: `context.mode.update payload.thresholds.${key} must be a finite number when provided`
+        };
       }
     }
     validatedThresholds = {
@@ -347,11 +408,17 @@ function validateContextModeUpdatePayload(payload) {
   }
   const preserveK = payload["preserveK"];
   if (preserveK !== void 0 && !isFiniteNumber(preserveK)) {
-    return { ok: false, message: "context.mode.update payload.preserveK must be a finite number when provided" };
+    return {
+      ok: false,
+      message: "context.mode.update payload.preserveK must be a finite number when provided"
+    };
   }
   const eliseThreshold = payload["eliseThreshold"];
   if (eliseThreshold !== void 0 && !isFiniteNumber(eliseThreshold)) {
-    return { ok: false, message: "context.mode.update payload.eliseThreshold must be a finite number when provided" };
+    return {
+      ok: false,
+      message: "context.mode.update payload.eliseThreshold must be a finite number when provided"
+    };
   }
   return {
     ok: true,
@@ -369,28 +436,31 @@ function validateShellOpenPayload(payload) {
   if (!isRecord(payload)) {
     return { ok: false, message: "shell.open payload must be an object with string path" };
   }
-  const path16 = payload["path"];
-  if (typeof path16 !== "string" || path16.trim().length === 0) {
+  const path17 = payload["path"];
+  if (typeof path17 !== "string" || path17.trim().length === 0) {
     return { ok: false, message: "shell.open payload.path must be a non-empty string" };
   }
   const target = payload["target"];
   if (target !== void 0 && target !== "file" && target !== "terminal") {
-    return { ok: false, message: 'shell.open payload.target must be "file" or "terminal" when provided' };
+    return {
+      ok: false,
+      message: 'shell.open payload.target must be "file" or "terminal" when provided'
+    };
   }
-  return { ok: true, value: { path: path16, target } };
+  return { ok: true, value: { path: path17, target } };
 }
 function validateGitDiffPayload(payload) {
   if (!isRecord(payload)) {
     return { ok: false, message: "git.diff payload must be an object" };
   }
-  const path16 = payload["path"];
-  if (path16 === void 0 || path16 === null) {
+  const path17 = payload["path"];
+  if (path17 === void 0 || path17 === null) {
     return { ok: true, value: { path: "" } };
   }
-  if (typeof path16 !== "string") {
+  if (typeof path17 !== "string") {
     return { ok: false, message: "git.diff payload.path must be a string when provided" };
   }
-  return { ok: true, value: { path: path16 } };
+  return { ok: true, value: { path: path17 } };
 }
 function validateProjectsAddPayload(payload) {
   if (!isRecord(payload)) {
@@ -570,7 +640,7 @@ async function handlePlanItemUpdate(ctx, ws, payload) {
     return;
   }
   try {
-    const { loadPlan, savePlan, mutatePlan, setPlanItemStatus } = await import("@wrongstack/core");
+    const { mutatePlan, setPlanItemStatus } = await import("@wrongstack/core");
     let changed = false;
     const plan = await mutatePlan(planPath, sessionId, async (p) => {
       const before = p.updatedAt;
@@ -650,7 +720,7 @@ import {
   createTieredBrainArbiter
 } from "@wrongstack/core";
 import * as fs13 from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 
 // src/server/http-server.ts
 import * as fs from "fs/promises";
@@ -827,7 +897,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
     return;
   }
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths2, DefaultSessionStore: DefaultSessionStore4, DefaultSessionReader: DefaultSessionReader2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths2, DefaultSessionStore: DefaultSessionStore3, DefaultSessionReader: DefaultSessionReader2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -836,7 +906,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
       return;
     }
     const paths = resolveWstackPaths2({ projectRoot: entry.projectRoot, globalRoot });
-    const store = new DefaultSessionStore4({ dir: paths.projectSessions });
+    const store = new DefaultSessionStore3({ dir: paths.projectSessions });
     const reader = new DefaultSessionReader2({ store });
     const rawEntries = [];
     for await (const ev of reader.replay(sessionId)) {
@@ -1522,8 +1592,8 @@ function isInside(root, target) {
 }
 
 // src/server/file-handlers.ts
-import * as fs3 from "fs/promises";
-import * as path3 from "path";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
 import { atomicWrite } from "@wrongstack/core";
 
 // src/server/file-picker.ts
@@ -1574,6 +1644,34 @@ function rankFiles(paths, query, limit) {
   return scored.slice(0, limit).map((s) => s.path);
 }
 
+// src/server/path-containment.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+function isPathInside(root, target) {
+  const relative3 = path3.relative(root, target);
+  return relative3 === "" || !relative3.startsWith("..") && !path3.isAbsolute(relative3);
+}
+async function resolveWorkingDirInsideProject(projectRoot, inputPath) {
+  const resolved = path3.resolve(projectRoot, inputPath);
+  let stat3;
+  try {
+    stat3 = await fs3.stat(resolved);
+  } catch {
+    throw new Error(`Directory not found or not accessible: ${resolved}`);
+  }
+  if (!stat3.isDirectory()) {
+    throw new Error(`Directory not found or not accessible: ${resolved}`);
+  }
+  const [realProjectRoot, realResolved] = await Promise.all([
+    fs3.realpath(projectRoot),
+    fs3.realpath(resolved)
+  ]);
+  if (!isPathInside(realProjectRoot, realResolved)) {
+    throw new Error(`Path must stay inside the project root: ${projectRoot}`);
+  }
+  return resolved;
+}
+
 // src/server/ws-utils.ts
 import { randomBytes } from "crypto";
 import { WebSocket } from "ws";
@@ -1604,23 +1702,73 @@ function generateAuthToken() {
 }
 
 // src/server/file-handlers.ts
+async function resolveFileInsideProject(projectRoot, filePath) {
+  const resolved = path4.resolve(projectRoot, filePath);
+  if (!isPathInside(projectRoot, resolved)) {
+    throw new Error("Path outside project root");
+  }
+  const { parent, base } = splitParentAndBase(resolved);
+  const realProjectRoot = await fs4.realpath(projectRoot);
+  const realParent = await realpathAllowMissing(parent);
+  const realFull = path4.join(realParent, base);
+  if (!isPathInside(realProjectRoot, realFull)) {
+    throw new Error("Path outside project root");
+  }
+  return realFull;
+}
+function splitParentAndBase(p) {
+  const base = path4.basename(p);
+  const parent = path4.dirname(p);
+  return { parent, base };
+}
+async function realpathAllowMissing(p) {
+  try {
+    return await fs4.realpath(p);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const segments = [];
+  let cursor = p;
+  while (true) {
+    const parent = path4.dirname(cursor);
+    if (parent === cursor) {
+      throw new Error("Path outside project root");
+    }
+    segments.unshift(path4.basename(cursor));
+    try {
+      const realParent = await fs4.realpath(parent);
+      return path4.join(realParent, ...segments);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      cursor = parent;
+    }
+  }
+}
 async function handleFilesTree(ws, msg, projectRoot) {
   const payload = msg.payload;
   const rawPath = payload?.path?.trim();
-  const treeRoot = rawPath && rawPath !== "." ? path3.resolve(projectRoot, rawPath) : projectRoot;
-  if (!treeRoot.startsWith(projectRoot + path3.sep) && treeRoot !== projectRoot) {
+  let treeRoot;
+  let realProjectRoot;
+  try {
+    if (rawPath && rawPath !== ".") {
+      treeRoot = await resolveWorkingDirInsideProject(projectRoot, rawPath);
+    } else {
+      treeRoot = projectRoot;
+    }
+    realProjectRoot = await fs4.realpath(projectRoot);
+  } catch {
     send(ws, {
       type: "files.tree",
       payload: { root: projectRoot, tree: [], error: "Path outside project root" }
     });
     return;
   }
-  const pathPrefix = treeRoot === projectRoot ? "" : (path3.relative(projectRoot, treeRoot) + "/").replace(/\\/g, "/");
+  const pathPrefix = treeRoot === projectRoot ? "" : (path4.relative(projectRoot, treeRoot) + "/").replace(/\\/g, "/");
   async function buildTree(dir, rel, depth) {
     if (depth > 10) return [];
     let entries = [];
     try {
-      entries = await fs3.readdir(dir, { withFileTypes: true });
+      entries = await fs4.readdir(dir, { withFileTypes: true });
     } catch {
       return [];
     }
@@ -1632,11 +1780,20 @@ async function handleFilesTree(ws, msg, projectRoot) {
     for (const e of entries) {
       if (isHiddenEntry(e.name)) continue;
       const childRel = rel ? `${rel}/${e.name}` : e.name;
-      const childAbs = path3.join(dir, e.name);
+      const childAbs = path4.join(dir, e.name);
       const childPath = pathPrefix + childRel;
       if (e.isDirectory()) {
         if (SKIP_DIRS.has(e.name)) continue;
-        const children = await buildTree(childAbs, childRel, depth + 1);
+        let realChild;
+        try {
+          realChild = await fs4.realpath(childAbs);
+        } catch {
+          continue;
+        }
+        if (!isPathInside(realProjectRoot, realChild)) {
+          continue;
+        }
+        const children = await buildTree(realChild, childRel, depth + 1);
         nodes.push({ name: e.name, path: childPath, type: "directory", children });
       } else if (e.isFile()) {
         nodes.push({ name: e.name, path: childPath, type: "file" });
@@ -1646,10 +1803,10 @@ async function handleFilesTree(ws, msg, projectRoot) {
   }
   try {
     const tree = await buildTree(treeRoot, "", 0);
-    const rootLabel = treeRoot === projectRoot ? projectRoot : path3.relative(projectRoot, treeRoot) || ".";
+    const rootLabel = treeRoot === projectRoot ? projectRoot : path4.relative(projectRoot, treeRoot) || ".";
     send(ws, { type: "files.tree", payload: { root: rootLabel, tree } });
   } catch (err) {
-    const rootLabel = treeRoot === projectRoot ? projectRoot : path3.relative(projectRoot, treeRoot) || ".";
+    const rootLabel = treeRoot === projectRoot ? projectRoot : path4.relative(projectRoot, treeRoot) || ".";
     send(ws, {
       type: "files.tree",
       payload: { root: rootLabel, tree: [], error: errMessage(err) }
@@ -1658,13 +1815,15 @@ async function handleFilesTree(ws, msg, projectRoot) {
 }
 async function handleFilesRead(ws, msg, projectRoot) {
   const { filePath } = msg.payload;
-  const resolved = path3.resolve(projectRoot, filePath);
-  if (!resolved.startsWith(projectRoot + path3.sep) && resolved !== projectRoot) {
+  let realResolved;
+  try {
+    realResolved = await resolveFileInsideProject(projectRoot, filePath);
+  } catch {
     send(ws, { type: "files.read", payload: { filePath, content: "", error: "Forbidden" } });
     return;
   }
   try {
-    const content = await fs3.readFile(resolved, "utf8");
+    const content = await fs4.readFile(realResolved, "utf8");
     send(ws, { type: "files.read", payload: { filePath, content } });
   } catch (err) {
     send(ws, {
@@ -1675,16 +1834,18 @@ async function handleFilesRead(ws, msg, projectRoot) {
 }
 async function handleFilesWrite(ws, msg, projectRoot, opts = {}) {
   const { filePath, content } = msg.payload;
-  const resolved = path3.resolve(projectRoot, filePath);
-  if (!resolved.startsWith(projectRoot + path3.sep) && resolved !== projectRoot) {
+  let realResolved;
+  try {
+    realResolved = await resolveFileInsideProject(projectRoot, filePath);
+  } catch {
     send(ws, { type: "files.written", payload: { filePath, success: false, error: "Forbidden" } });
     return;
   }
   try {
-    await atomicWrite(resolved, content);
+    await atomicWrite(realResolved, content);
     send(ws, { type: "files.written", payload: { filePath, success: true } });
     if (opts.onWritten) {
-      void Promise.resolve(opts.onWritten(resolved)).catch(() => void 0);
+      void Promise.resolve(opts.onWritten(realResolved)).catch(() => void 0);
     }
   } catch (err) {
     send(ws, {
@@ -1696,8 +1857,16 @@ async function handleFilesWrite(ws, msg, projectRoot, opts = {}) {
 async function handleFilesList(ws, msg, projectRoot) {
   const payload = msg.payload ?? {};
   const limit = payload.limit ?? 50;
-  const listRoot = payload.path ? path3.resolve(projectRoot, payload.path) : projectRoot;
-  if (!listRoot.startsWith(projectRoot + path3.sep) && listRoot !== projectRoot) {
+  let listRoot;
+  let realProjectRoot;
+  try {
+    if (payload.path) {
+      listRoot = await resolveWorkingDirInsideProject(projectRoot, payload.path);
+    } else {
+      listRoot = projectRoot;
+    }
+    realProjectRoot = await fs4.realpath(projectRoot);
+  } catch {
     send(ws, { type: "files.list", payload: { files: [] } });
     return;
   }
@@ -1706,7 +1875,7 @@ async function handleFilesList(ws, msg, projectRoot) {
     if (depth > 8 || results.length >= 600) return;
     let entries = [];
     try {
-      entries = await fs3.readdir(dir, { withFileTypes: true });
+      entries = await fs4.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -1716,7 +1885,16 @@ async function handleFilesList(ws, msg, projectRoot) {
       const childRel = rel ? `${rel}/${e.name}` : e.name;
       if (e.isDirectory()) {
         if (SKIP_DIRS.has(e.name)) continue;
-        await walk(path3.join(dir, e.name), childRel, depth + 1);
+        let realChild;
+        try {
+          realChild = await fs4.realpath(path4.join(dir, e.name));
+        } catch {
+          continue;
+        }
+        if (!isPathInside(realProjectRoot, realChild)) {
+          continue;
+        }
+        await walk(realChild, childRel, depth + 1);
       } else if (e.isFile()) {
         results.push(childRel);
       }
@@ -1730,7 +1908,7 @@ async function handleFilesList(ws, msg, projectRoot) {
 }
 
 // src/server/completion-handlers.ts
-import * as path4 from "path";
+import * as path5 from "path";
 import { searchCodebaseIndex } from "@wrongstack/tools/codebase-index/index";
 var MAX_PREFIX_CHARS = 12e3;
 var MAX_SUFFIX_CHARS = 4e3;
@@ -1805,8 +1983,8 @@ async function handleCompletionRequest(ws, msg, opts) {
     return;
   }
   const payload = parsed.payload;
-  const projectRoot = path4.resolve(opts.projectRoot);
-  const resolved = path4.resolve(projectRoot, payload.filePath);
+  const projectRoot = path5.resolve(opts.projectRoot);
+  const resolved = path5.resolve(projectRoot, payload.filePath);
   if (!isInside2(projectRoot, resolved)) {
     send(ws, {
       type: "completion.result",
@@ -2205,7 +2383,7 @@ function buildSearchQuery(linePrefix, filePath) {
   if (memberMatch?.[1]) return memberMatch[1];
   const token = linePrefix.match(/([A-Za-z_$][\w$]*)$/)?.[1];
   if (token && token.length >= 2) return token;
-  return path4.basename(filePath, path4.extname(filePath));
+  return path5.basename(filePath, path5.extname(filePath));
 }
 function currentLinePrefix(prefix) {
   const idx = Math.max(prefix.lastIndexOf("\n"), prefix.lastIndexOf("\r"));
@@ -2235,7 +2413,7 @@ function head(value, max) {
   return value.length <= max ? value : value.slice(0, max);
 }
 function isInside2(root, target) {
-  return target === root || target.startsWith(root + path4.sep);
+  return target === root || target.startsWith(root + path5.sep);
 }
 
 // src/server/memory-handlers.ts
@@ -2489,8 +2667,8 @@ async function handleMcpDiscover(ws, msg, globalConfigPath, mcpRegistry) {
 }
 
 // src/server/skills-handlers.ts
-import { promises as fs4 } from "fs";
-import path5 from "path";
+import { promises as fs5 } from "fs";
+import path6 from "path";
 import JSZip from "jszip";
 import { atomicWrite as atomicWrite2 } from "@wrongstack/core";
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
@@ -2561,19 +2739,19 @@ async function handleSkillsContent(ws, ctx, msg) {
       send(ws, { type: "skills.content", payload: { name: name2, body: "", path: "", source, relatedFiles: [], references: [], error: `Skill "${name2}" not found` } });
       return;
     }
-    const body = await fs4.readFile(entry.path, "utf8");
-    const skillDir = path5.dirname(entry.path);
+    const body = await fs5.readFile(entry.path, "utf8");
+    const skillDir = path6.dirname(entry.path);
     let relatedFiles = [];
     try {
-      const files = await fs4.readdir(skillDir);
-      relatedFiles = files.filter((f) => f !== path5.basename(entry.path)).map((f) => path5.join(skillDir, f));
+      const files = await fs5.readdir(skillDir);
+      relatedFiles = files.filter((f) => f !== path6.basename(entry.path)).map((f) => path6.join(skillDir, f));
     } catch {
     }
     const nameLower = name2.toLowerCase();
     const refResults = await Promise.all(
       entries.filter((e) => e.name.toLowerCase() !== nameLower).map(async (e) => {
         try {
-          const content = await fs4.readFile(e.path, "utf8");
+          const content = await fs5.readFile(e.path, "utf8");
           return [e.name, content.toLowerCase().includes(nameLower)];
         } catch {
           return [e.name, false];
@@ -2663,14 +2841,14 @@ async function handleSkillsCreate(ws, ctx, msg) {
   }
   const createPayload = parsed.value;
   try {
-    const targetDir = createPayload.scope === "global" ? path5.join(wstackGlobalRoot(), "skills", createPayload.name.trim()) : path5.join(ctx.projectRoot, ".wrongstack", "skills", createPayload.name.trim());
+    const targetDir = createPayload.scope === "global" ? path6.join(wstackGlobalRoot(), "skills", createPayload.name.trim()) : path6.join(ctx.projectRoot, ".wrongstack", "skills", createPayload.name.trim());
     try {
-      await fs4.access(targetDir);
+      await fs5.access(targetDir);
       send(ws, { type: "skills.created", payload: { success: false, error: `Skill "${createPayload.name}" already exists` } });
       return;
     } catch {
     }
-    await fs4.mkdir(targetDir, { recursive: true });
+    await fs5.mkdir(targetDir, { recursive: true });
     const lines = createPayload.description.trim().split("\n");
     const firstLine = lines[0].trim();
     const bodyLines = lines.slice(1).map((l) => l.trim()).filter(Boolean);
@@ -2718,13 +2896,13 @@ ${trigger}
       "- `bug-hunter` \u2014 for systematic bug detection patterns",
       "- `output-standards` \u2014 for standardized `<next_steps>` formatting"
     ].join("\n");
-    await atomicWrite2(path5.join(targetDir, "SKILL.md"), skillContent);
+    await atomicWrite2(path6.join(targetDir, "SKILL.md"), skillContent);
     send(ws, {
       type: "skills.created",
       payload: {
         success: true,
         error: null,
-        skill: { name: createPayload.name.trim(), path: path5.join(targetDir, "SKILL.md"), scope: createPayload.scope }
+        skill: { name: createPayload.name.trim(), path: path6.join(targetDir, "SKILL.md"), scope: createPayload.scope }
       }
     });
   } catch (err) {
@@ -2788,23 +2966,23 @@ import {
   Agent,
   AutoCompactionMiddleware,
   Context,
-  DefaultMemoryStore as DefaultMemoryStore2,
-  DefaultModeStore as DefaultModeStore2,
+  DefaultMemoryStore,
+  DefaultModeStore,
   DefaultModelsRegistry,
   DefaultSessionReader,
-  DefaultSessionStore as DefaultSessionStore3,
-  DefaultSkillLoader as DefaultSkillLoader2,
-  DefaultSystemPromptBuilder as DefaultSystemPromptBuilder4,
-  DefaultTokenCounter as DefaultTokenCounter2,
+  DefaultSessionStore as DefaultSessionStore2,
+  DefaultSkillLoader,
+  DefaultSystemPromptBuilder as DefaultSystemPromptBuilder3,
+  DefaultTokenCounter,
   AnnotationsStore,
   CollaborationBus,
   collabPauseMiddleware,
   collabInjectMiddleware,
   estimateRequestTokensCalibrated,
   EventBus,
-  createStrategyCompactor as createStrategyCompactor2,
+  createStrategyCompactor,
   ProviderRegistry,
-  TOKENS as TOKENS2,
+  TOKENS,
   ToolRegistry,
   atomicWrite as atomicWrite6,
   createDefaultPipelines,
@@ -2813,6 +2991,7 @@ import {
   DEFAULT_CONTEXT_WINDOW_MODE_ID as DEFAULT_CONTEXT_WINDOW_MODE_ID2,
   DEFAULT_SESSION_PRUNE_DAYS,
   DEFAULT_TOOLS_CONFIG,
+  applyToolDescriptionModes,
   resolveContextWindowPolicy as resolveContextWindowPolicy2,
   enhanceUserPrompt,
   gatedEnhancerReasoning,
@@ -2822,109 +3001,10 @@ import {
 import { ToolExecutor } from "@wrongstack/core/execution";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets as encryptConfigSecrets2 } from "@wrongstack/core/security";
 import { buildProviderFactoriesFromRegistry, makeProviderFromConfig } from "@wrongstack/providers";
-import { builtinToolsPack, forgetTool, rememberTool, searchMemoryTool, relatedMemoryTool } from "@wrongstack/tools";
+import { builtinToolsPack, configureExecPolicy, ensureSessionShell, forgetTool, rememberTool, searchMemoryTool, relatedMemoryTool } from "@wrongstack/tools";
 import { MCPRegistry } from "@wrongstack/mcp";
 import { WebSocket as WebSocket2, WebSocketServer } from "ws";
-
-// ../runtime/src/container.ts
-import {
-  Container,
-  DefaultConfigStore,
-  DefaultErrorHandler,
-  DefaultMemoryStore,
-  DefaultModeStore,
-  DefaultPermissionPolicy,
-  DefaultRetryPolicy,
-  DefaultSecretScrubber,
-  DefaultSessionStore,
-  DefaultSkillLoader,
-  DefaultSystemPromptBuilder,
-  DefaultTokenCounter,
-  createStrategyCompactor,
-  buildRecoveryStrategies,
-  TOKENS
-} from "@wrongstack/core";
-function createDefaultContainer(opts) {
-  const { config, wpaths, logger, modelsRegistry } = opts;
-  const container = new Container();
-  const configStore = new DefaultConfigStore(config);
-  container.bind(TOKENS.ConfigStore, () => configStore);
-  container.bind(TOKENS.Logger, () => logger);
-  container.bind(TOKENS.SecretScrubber, () => new DefaultSecretScrubber());
-  container.bind(TOKENS.RetryPolicy, () => new DefaultRetryPolicy());
-  container.bind(
-    TOKENS.ErrorHandler,
-    () => new DefaultErrorHandler(
-      buildRecoveryStrategies({
-        compactor: container.resolve(TOKENS.Compactor),
-        modelsRegistry
-      })
-    )
-  );
-  container.bind(TOKENS.ModelsRegistry, () => modelsRegistry);
-  container.bind(
-    TOKENS.TokenCounter,
-    () => new DefaultTokenCounter({ registry: modelsRegistry, providerId: config.provider })
-  );
-  const modeStore = new DefaultModeStore({ directory: wpaths.configDir });
-  container.bind(TOKENS.ModeStore, () => modeStore);
-  container.bind(
-    TOKENS.SessionStore,
-    () => new DefaultSessionStore({
-      dir: wpaths.projectSessions,
-      // Scrub secrets out of persisted user/model turns (F-06). Tool output
-      // is already scrubbed by the executor.
-      secretScrubber: container.resolve(TOKENS.SecretScrubber)
-    })
-  );
-  const memoryStore = new DefaultMemoryStore({ paths: wpaths, events: opts.events });
-  container.bind(TOKENS.MemoryStore, () => memoryStore);
-  const skillLoader = new DefaultSkillLoader({ paths: wpaths, bundledDir: opts.bundledSkillsDir });
-  container.bind(TOKENS.SkillLoader, () => skillLoader);
-  if (opts.systemPrompt) {
-    container.bind(
-      TOKENS.SystemPromptBuilder,
-      () => new DefaultSystemPromptBuilder(opts.systemPrompt)
-    );
-  }
-  container.bind(
-    TOKENS.PermissionPolicy,
-    () => {
-      const policyOptions = {
-        trustFile: wpaths.projectTrust,
-        yolo: opts.permission?.yolo ?? false,
-        yoloDestructive: opts.permission?.yoloDestructive ?? opts.permission?.forceAllYolo ?? false,
-        confirmDestructive: opts.permission?.confirmDestructive ?? false
-      };
-      if (opts.permission?.promptDelegate !== void 0) {
-        policyOptions.promptDelegate = opts.permission.promptDelegate;
-      }
-      return new DefaultPermissionPolicy(policyOptions);
-    }
-  );
-  container.bind(
-    TOKENS.Compactor,
-    () => (
-      // Strategy comes from config.context.strategy: 'hybrid' (default, lossless
-      // rules, no LLM), 'intelligent' (LLM summarization), or 'selective'
-      // (LLM-driven selection). The LLM strategies resolve their provider from
-      // ctx at compact()-time, so binding here (before context.provider exists)
-      // is safe. preserveK / eliseThreshold are class-level fallbacks; the active
-      // ContextWindowPolicy in ctx.meta normally overrides both at runtime.
-      // eliseThreshold is a TOKEN COUNT — a previous value of 0.7 elided
-      // essentially every tool_result (anything > 1 token).
-      createStrategyCompactor({
-        strategy: config.context?.strategy,
-        preserveK: opts.compactor?.preserveK ?? 10,
-        eliseThreshold: opts.compactor?.eliseThreshold ?? 2e3,
-        smart: true,
-        summarizerModel: config.context?.summarizerModel,
-        llmSelector: config.context?.llmSelector
-      })
-    )
-  );
-  return container;
-}
+import { createDefaultContainer, makeLightSubagentFactory } from "@wrongstack/runtime";
 
 // src/server/boot.ts
 import {
@@ -2944,6 +3024,7 @@ function patchConfig(config, updates) {
 import { spawnSync } from "child_process";
 import { toErrorMessage } from "@wrongstack/core/utils";
 import {
+  assignNickname,
   AutoPhasePlanner,
   PhaseGraphBuilder,
   PhaseOrchestrator,
@@ -2981,6 +3062,8 @@ var AutoPhaseWebSocketHandler = class {
   abort = null;
   /** Optional per-phase git-worktree isolation (lazily created at start). */
   worktrees = null;
+  /** Per-run worker identities so the board can show "who is on what". */
+  usedNicknames = /* @__PURE__ */ new Set();
   addClient(ws) {
     const client = { ws, id: crypto.randomUUID() };
     this.clients.add(client);
@@ -3023,6 +3106,29 @@ var AutoPhaseWebSocketHandler = class {
         await this.handleTaskStatusChange(taskId, status);
         break;
       }
+      case "autophase.moveTask": {
+        const { taskId, toPhaseId } = msg.payload;
+        if (this.orchestrator?.moveTask(taskId, toPhaseId)) this.afterBoardMutation();
+        break;
+      }
+      case "autophase.assignTask": {
+        const { taskId, agentId, agentName } = msg.payload;
+        if (this.orchestrator?.setTaskAssignee(taskId, agentId, agentName)) this.afterBoardMutation();
+        break;
+      }
+      case "autophase.addTask": {
+        const { phaseId, title, description, type, priority } = msg.payload;
+        if (title?.trim() && this.orchestrator?.addTask(phaseId, { title: title.trim(), description, type, priority })) {
+          this.afterBoardMutation();
+        }
+        break;
+      }
+      case "autophase.retryTask":
+      case "autophase.runTask": {
+        const { taskId } = msg.payload;
+        if (this.orchestrator?.requeueTask(taskId)) this.afterBoardMutation();
+        break;
+      }
       case "autophase.toggleAutonomous": {
         const autonomous = msg.payload?.autonomous ?? !this.graph?.autonomous;
         if (this.graph) {
@@ -3150,6 +3256,13 @@ var AutoPhaseWebSocketHandler = class {
     return this.defaultPhases();
   }
   async executeTaskWithAgent(task, phaseId, env) {
+    if (!task.assignee) {
+      const nick = assignNickname("executor", this.usedNicknames);
+      this.usedNicknames.add(nick.key);
+      task.assignee = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
+      task.updatedAt = Date.now();
+      this.broadcastState();
+    }
     const prompt = `Execute task: ${task.title}
 
 Description: ${task.description}
@@ -3165,6 +3278,11 @@ Type: ${task.type}`;
       this.context.cwd = prevCwd;
     }
   }
+  /** Persist + broadcast after an interactive board mutation. */
+  afterBoardMutation() {
+    if (this.graph) void this.store.save(this.graph);
+    this.broadcastState();
+  }
   async handleTaskStatusChange(taskId, status) {
     if (!this.graph) return;
     for (const phase of this.graph.phases.values()) {
@@ -3208,23 +3326,7 @@ Type: ${task.type}`;
       (sum, p) => sum + Array.from(p.taskGraph.nodes.values()).filter((t) => t.status === "completed").length,
       0
     );
-    const phaseItems = phases.map((p) => ({
-      id: p.id,
-      name: p.name,
-      description: p.description,
-      status: p.status,
-      priority: p.priority,
-      estimateHours: p.estimateHours,
-      actualDurationMs: p.actualDurationMs,
-      startedAt: p.startedAt,
-      completedAt: p.completedAt,
-      progressPercent: p.taskGraph.nodes.size > 0 ? Math.round(Array.from(p.taskGraph.nodes.values()).filter((t) => t.status === "completed").length / p.taskGraph.nodes.size * 100) : 0,
-      taskCount: p.taskGraph.nodes.size,
-      completedTasks: Array.from(p.taskGraph.nodes.values()).filter((t) => t.status === "completed").length,
-      assignedAgents: p.assignedAgents,
-      isActive: p.id === currentActiveId
-    }));
-    const taskItems = activePhase ? Array.from(activePhase.taskGraph.nodes.values()).map((t) => ({
+    const mapTask = (t) => ({
       id: t.id,
       title: t.title,
       description: t.description,
@@ -3237,8 +3339,39 @@ Type: ${task.type}`;
       tags: t.tags || [],
       startedAt: t.startedAt,
       completedAt: t.completedAt
-    })) : [];
+    });
+    const phaseItems = phases.map((p) => {
+      const nodes = Array.from(p.taskGraph.nodes.values());
+      const done = nodes.filter((t) => t.status === "completed").length;
+      return {
+        id: p.id,
+        name: p.name,
+        description: p.description,
+        status: p.status,
+        priority: p.priority,
+        estimateHours: p.estimateHours,
+        actualDurationMs: p.actualDurationMs,
+        startedAt: p.startedAt,
+        completedAt: p.completedAt,
+        progressPercent: nodes.length > 0 ? Math.round(done / nodes.length * 100) : 0,
+        taskCount: nodes.length,
+        completedTasks: done,
+        assignedAgents: p.assignedAgents,
+        isActive: p.id === currentActiveId,
+        // Every phase carries its full task list so the board can render each
+        // phase as a column (not just the selected one).
+        tasks: nodes.map(mapTask)
+      };
+    });
+    const taskItems = activePhase ? Array.from(activePhase.taskGraph.nodes.values()).map(mapTask) : [];
     const completedPhases = phases.filter((p) => p.status === "completed").length;
+    const failedPhases = phases.filter((p) => p.status === "failed").length;
+    const failedTasks = phases.reduce(
+      (sum, p) => sum + Array.from(p.taskGraph.nodes.values()).filter((t) => t.status === "failed").length,
+      0
+    );
+    const lastFailed = phases.filter((p) => p.status === "failed").sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0))[0];
+    const lastError = lastFailed ? `${lastFailed.name}: ${lastFailed.metadata?.integrationError ?? "phase failed"}` : null;
     return {
       title: this.graph.title,
       phases: phaseItems,
@@ -3247,7 +3380,18 @@ Type: ${task.type}`;
       overallPercent: phases.length > 0 ? Math.round(completedPhases / phases.length * 100) : 0,
       autonomous: this.graph.autonomous,
       totalTasks,
-      completedTasks
+      completedTasks,
+      // Structured progress + lastError consumed by the autophase store (were
+      // defined client-side but never sent, so they stayed null on the board).
+      progress: {
+        totalPhases: phases.length,
+        completed: completedPhases,
+        failed: failedPhases,
+        totalTasks,
+        completedTasks,
+        failedTasks
+      },
+      lastError
     };
   }
   sendState(client) {
@@ -3270,6 +3414,510 @@ Type: ${task.type}`;
   }
 };
 
+// src/server/specs-ws-handler.ts
+import {
+  computeTaskProgress,
+  SpecStore,
+  TaskGraphStore
+} from "@wrongstack/core";
+var SpecsWebSocketHandler = class {
+  specStore;
+  graphStore;
+  clients = /* @__PURE__ */ new Set();
+  constructor(specsDir, taskGraphsDir) {
+    this.specStore = new SpecStore({ baseDir: specsDir });
+    this.graphStore = new TaskGraphStore({ baseDir: taskGraphsDir });
+  }
+  addClient(ws) {
+    const client = { ws, id: crypto.randomUUID() };
+    this.clients.add(client);
+    ws.on("close", () => this.clients.delete(client));
+    ws.on("error", () => this.clients.delete(client));
+    void this.sendList(client);
+  }
+  async handleMessage(msg) {
+    switch (msg.type) {
+      case "specs.list":
+        await this.broadcastList();
+        break;
+      case "specs.get": {
+        const specId = msg.payload?.specId;
+        if (specId) await this.broadcastDetail(specId);
+        break;
+      }
+      case "specs.taskStatus": {
+        const { graphId, taskId, status } = msg.payload;
+        await this.updateTaskStatus(graphId, taskId, status);
+        break;
+      }
+    }
+  }
+  // ── List ──────────────────────────────────────────────────────────────────
+  async buildList() {
+    const [specs, graphs] = await Promise.all([this.specStore.list(), this.graphStore.list()]);
+    return specs.map((s, i) => {
+      const graph = graphs.find((g) => g.specId === s.id);
+      return {
+        id: s.id,
+        // FORGE-style display id (spec-001…). The real UUID stays in `id`.
+        displayId: `spec-${String(i + 1).padStart(3, "0")}`,
+        title: s.title,
+        status: s.status,
+        graphId: graph?.id,
+        total: graph?.nodeCount ?? 0,
+        completed: graph?.completedCount ?? 0
+      };
+    });
+  }
+  async broadcastList() {
+    this.broadcast({ type: "specs.list", payload: { specs: await this.buildList() } });
+  }
+  async sendList(client) {
+    this.send(client, { type: "specs.list", payload: { specs: await this.buildList() } });
+  }
+  // ── Detail (dependency board) ───────────────────────────────────────────────
+  async broadcastDetail(specId) {
+    const spec = await this.specStore.load(specId);
+    const graph = await this.findGraphForSpec(specId);
+    if (!spec || !graph) {
+      this.broadcast({ type: "specs.detail", payload: { specId, columns: [], notFound: true } });
+      return;
+    }
+    this.broadcast({ type: "specs.detail", payload: this.buildDetail(spec, graph) });
+  }
+  async findGraphForSpec(specId) {
+    const entry = (await this.graphStore.list()).find((g) => g.specId === specId);
+    if (!entry) return null;
+    return this.graphStore.load(entry.id);
+  }
+  buildDetail(spec, graph) {
+    const nodes = Array.from(graph.nodes.values()).sort((a, b) => a.createdAt - b.createdAt);
+    const shortId = /* @__PURE__ */ new Map();
+    nodes.forEach((n, i) => {
+      shortId.set(n.id, `t${String(i + 1).padStart(2, "0")}`);
+    });
+    const blockers = /* @__PURE__ */ new Map();
+    for (const n of nodes) blockers.set(n.id, []);
+    for (const e of graph.edges) {
+      if (e.type === "depends_on") blockers.get(e.to)?.push(e.from);
+    }
+    const statusOf = (id) => graph.nodes.get(id)?.status;
+    const depthCache = /* @__PURE__ */ new Map();
+    const depthOf = (id, seen = /* @__PURE__ */ new Set()) => {
+      const cached = depthCache.get(id);
+      if (cached !== void 0) return cached;
+      if (seen.has(id)) return 0;
+      seen.add(id);
+      const deps2 = blockers.get(id) ?? [];
+      const d = deps2.length === 0 ? 0 : 1 + Math.max(...deps2.map((b) => depthOf(b, seen)));
+      depthCache.set(id, d);
+      return d;
+    };
+    const toBoardTask = (n) => {
+      const deps2 = blockers.get(n.id) ?? [];
+      const allDepsDone = deps2.every((b) => statusOf(b) === "completed");
+      const displayStatus = n.status === "pending" && deps2.length > 0 && allDepsDone ? "queued" : n.status;
+      return {
+        id: n.id,
+        shortId: shortId.get(n.id) ?? n.id.slice(0, 6),
+        title: n.title,
+        description: n.description,
+        priority: n.priority,
+        type: n.type,
+        status: n.status,
+        displayStatus,
+        deps: deps2.map((b) => shortId.get(b) ?? b.slice(0, 6))
+      };
+    };
+    const byDepth = /* @__PURE__ */ new Map();
+    for (const n of nodes) {
+      const d = depthOf(n.id);
+      if (!byDepth.has(d)) byDepth.set(d, []);
+      byDepth.get(d)?.push(toBoardTask(n));
+    }
+    const columns = [...byDepth.keys()].sort((a, b) => a - b).map((d) => ({ label: d === 0 ? "Start" : `Phase ${d}`, tasks: byDepth.get(d) ?? [] }));
+    const progress = computeTaskProgress(graph);
+    return {
+      specId: spec.id,
+      graphId: graph.id,
+      title: spec.title,
+      overview: spec.overview,
+      status: spec.status,
+      total: progress.total,
+      completed: progress.completed,
+      running: progress.inProgress,
+      pending: progress.pending,
+      columns
+    };
+  }
+  async updateTaskStatus(graphId, taskId, status) {
+    const graph = await this.graphStore.load(graphId);
+    const node = graph?.nodes.get(taskId);
+    if (!graph || !node) return;
+    node.status = status;
+    node.updatedAt = Date.now();
+    graph.updatedAt = Date.now();
+    await this.graphStore.save(graph);
+    this.broadcastDetail(graph.specId).catch(() => {
+    });
+    await this.broadcastList();
+  }
+  // ── Transport ───────────────────────────────────────────────────────────────
+  broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const client of this.clients) {
+      if (client.ws.readyState === 1) client.ws.send(data);
+    }
+  }
+  send(client, msg) {
+    if (client.ws.readyState === 1) client.ws.send(JSON.stringify(msg));
+  }
+};
+
+// src/server/sdd-board-ws-handler.ts
+import { SddBoardStore } from "@wrongstack/core";
+var CONTROL_TYPES = /* @__PURE__ */ new Set([
+  "pause",
+  "resume",
+  "stop",
+  "retry",
+  "retry_all_failed",
+  "reassign",
+  // Per-task model / fallback / verification assignment + stop/delete (drained by start-sdd-run).
+  "set_task_model",
+  "set_task_fallbacks",
+  "set_task_verification",
+  "cancel_task",
+  "delete_task",
+  "split_task",
+  // Lifecycle (pair with a prior `stop`): sweep worktrees / revert merged commits.
+  "cleanup_worktrees",
+  "rollback"
+]);
+var SddBoardWebSocketHandler = class {
+  store;
+  clients = /* @__PURE__ */ new Set();
+  latest = null;
+  poll = null;
+  unsub = null;
+  constructor(boardsDir, events) {
+    this.store = new SddBoardStore({ baseDir: boardsDir });
+    if (events) {
+      const handler = (e) => {
+        this.latest = e.snapshot;
+        this.broadcast({ type: "sdd.board.snapshot", payload: e.snapshot });
+      };
+      this.unsub = events.on("sdd.board.snapshot", handler);
+    } else {
+      this.poll = setInterval(() => void this.pollLatest(), 1e3);
+    }
+  }
+  addClient(ws) {
+    const client = { ws, id: crypto.randomUUID() };
+    this.clients.add(client);
+    ws.on("close", () => this.clients.delete(client));
+    ws.on("error", () => this.clients.delete(client));
+    void this.sendCurrent(client);
+  }
+  async handleMessage(msg) {
+    if (msg.type === "sdd.board.get") {
+      await this.broadcastCurrent();
+      return;
+    }
+    if (msg.type === "sdd.board.list") {
+      const boards = await this.store.list();
+      this.broadcast({ type: "sdd.board.list", payload: { boards } });
+      return;
+    }
+    const action = msg.type.replace(/^sdd\.board\./, "");
+    if (CONTROL_TYPES.has(action)) {
+      const runId = msg.payload?.runId ?? this.latest?.runId ?? (await this.store.list())[0]?.runId;
+      if (runId) {
+        await this.store.appendControl(runId, {
+          ts: Date.now(),
+          type: action,
+          payload: msg.payload
+        });
+      }
+    }
+  }
+  dispose() {
+    if (this.poll) clearInterval(this.poll);
+    this.unsub?.();
+    this.poll = null;
+    this.unsub = null;
+  }
+  // ── internal ────────────────────────────────────────────────────────────
+  async pollLatest() {
+    const entry = (await this.store.list())[0];
+    if (!entry) return;
+    if (this.latest && this.latest.updatedAt >= entry.updatedAt && this.latest.runId === entry.runId) {
+      return;
+    }
+    const snap = await this.store.load(entry.runId);
+    if (snap) {
+      this.latest = snap;
+      this.broadcast({ type: "sdd.board.snapshot", payload: snap });
+    }
+  }
+  async sendCurrent(client) {
+    const snap = this.latest ?? await this.loadLatestFromDisk();
+    if (snap) this.send(client, { type: "sdd.board.snapshot", payload: snap });
+  }
+  async broadcastCurrent() {
+    const snap = this.latest ?? await this.loadLatestFromDisk();
+    if (snap) this.broadcast({ type: "sdd.board.snapshot", payload: snap });
+  }
+  async loadLatestFromDisk() {
+    const entry = (await this.store.list())[0];
+    return entry ? this.store.load(entry.runId) : null;
+  }
+  broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const client of this.clients) {
+      if (client.ws.readyState === 1) client.ws.send(data);
+    }
+  }
+  send(client, msg) {
+    if (client.ws.readyState === 1) client.ws.send(JSON.stringify(msg));
+  }
+};
+
+// src/server/sdd-wizard-ws-handler.ts
+var SddWizardWebSocketHandler = class {
+  constructor(deps2) {
+    this.deps = deps2;
+  }
+  deps;
+  clients = /* @__PURE__ */ new Set();
+  driver = null;
+  /** The agent's most recent question — paired with the next user answer. */
+  lastAgentText = "";
+  /** Guards against overlapping interview turns (one in flight at a time). */
+  busy = false;
+  addClient(ws) {
+    const client = { ws, id: crypto.randomUUID() };
+    this.clients.add(client);
+    ws.on("close", () => this.clients.delete(client));
+    ws.on("error", () => this.clients.delete(client));
+    if (this.driver) this.send(client, this.snapshotMsg());
+  }
+  async handleMessage(msg) {
+    try {
+      switch (msg.type) {
+        case "sdd.spec.start":
+          await this.onStart(String(msg.payload?.goal ?? "").trim());
+          break;
+        case "sdd.spec.message":
+          await this.onMessage(String(msg.payload?.text ?? ""));
+          break;
+        case "sdd.spec.approve":
+          await this.onApprove();
+          break;
+        case "sdd.spec.get":
+          if (this.driver) this.broadcast(this.snapshotMsg());
+          break;
+        case "sdd.run.start":
+          await this.onRunStart({
+            parallelSlots: msg.payload?.parallelSlots,
+            defaultModel: msg.payload?.model,
+            defaultProvider: msg.payload?.provider,
+            fallbackModels: Array.isArray(msg.payload?.fallbackModels) ? msg.payload?.fallbackModels : void 0
+          });
+          break;
+      }
+    } catch (err) {
+      this.busy = false;
+      this.broadcast({
+        type: "sdd.spec.error",
+        payload: { message: err instanceof Error ? err.message : String(err) }
+      });
+    }
+  }
+  // ── message handlers ──────────────────────────────────────────────────────
+  async onStart(goal) {
+    if (!goal) {
+      this.broadcast({ type: "sdd.spec.error", payload: { message: "A goal is required." } });
+      return;
+    }
+    if (this.busy) return;
+    this.driver = this.deps.makeDriver();
+    const prompt = this.driver.start(goal);
+    await this.runTurn(prompt);
+  }
+  async onMessage(text) {
+    if (!this.driver || this.busy) return;
+    if (this.driver.phase() === "questioning" && this.lastAgentText) {
+      this.driver.submitAnswer(this.lastAgentText, text);
+    } else {
+      this.driver.submitAnswer(this.lastAgentText || "(feedback)", text);
+    }
+    await this.runTurn(this.driver.currentPrompt());
+  }
+  async onApprove() {
+    if (!this.driver || this.busy) return;
+    const { phase, prompt } = await this.driver.approve();
+    if (phase === "executing") {
+      this.broadcast(this.snapshotMsg());
+      return;
+    }
+    await this.runTurn(prompt);
+  }
+  async onRunStart(opts) {
+    if (!this.driver) {
+      this.broadcast({ type: "sdd.spec.error", payload: { message: "No active spec session." } });
+      return;
+    }
+    const graph = await this.driver.ensureTaskGraph();
+    if (!graph) {
+      this.broadcast({
+        type: "sdd.spec.error",
+        payload: { message: "No spec yet \u2014 finish the interview before starting a run." }
+      });
+      return;
+    }
+    const { runId } = await this.deps.startRun(this.driver, opts);
+    this.broadcast({ type: "sdd.run.started", payload: { runId } });
+  }
+  // ── internals ───────────────────────────────────────────────────────────
+  /** Run one interview turn against the isolated agent, then ingest + broadcast. */
+  async runTurn(prompt) {
+    this.busy = true;
+    this.broadcast(this.snapshotMsg());
+    try {
+      const text = await this.deps.runInterviewTurn(prompt);
+      this.lastAgentText = text;
+      if (this.driver) await this.driver.ingestAgentOutput(text);
+      this.broadcast({ type: "sdd.spec.agent_text", payload: { text } });
+    } finally {
+      this.busy = false;
+      this.broadcast(this.snapshotMsg());
+    }
+  }
+  snapshotMsg() {
+    const snap = this.driver?.snapshot();
+    return {
+      type: "sdd.spec.snapshot",
+      payload: { ...snap, busy: this.busy }
+    };
+  }
+  broadcast(msg) {
+    const data = JSON.stringify(msg);
+    for (const client of this.clients) {
+      if (client.ws.readyState === 1) client.ws.send(data);
+    }
+  }
+  send(client, msg) {
+    if (client.ws.readyState === 1) client.ws.send(JSON.stringify(msg));
+  }
+};
+
+// src/server/sdd-wizard-wiring.ts
+import * as path7 from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  makeCommandVerifier,
+  makeLlmSubtaskGenerator,
+  SddBoardStore as SddBoardStore2,
+  SddInterviewDriver,
+  SddRunRegistry,
+  SddSupervisor,
+  SpecStore as SpecStore2,
+  startSddRun,
+  TaskGraphStore as TaskGraphStore2,
+  WorktreeManager as WorktreeManager2
+} from "@wrongstack/core";
+function buildSddWizardDeps(opts) {
+  const registry = new SddRunRegistry();
+  let isolatedSeq = 0;
+  const runIsolatedTurn = async (prompt, name2) => {
+    const result = await opts.subagentFactory({
+      id: `sdd-${name2.toLowerCase().replace(/\s+/g, "-")}-${isolatedSeq++}`,
+      role: "executor",
+      name: name2,
+      disabledTools: ["delegate"],
+      allowedCapabilities: ["fs.read", "net.outbound"]
+    });
+    try {
+      const res = await result.agent.run([{ type: "text", text: prompt }]);
+      return res.finalText ?? "";
+    } finally {
+      await result.dispose?.();
+    }
+  };
+  return {
+    makeDriver: () => new SddInterviewDriver({
+      specStore: new SpecStore2({ baseDir: opts.paths.projectSpecs }),
+      graphStore: new TaskGraphStore2({ baseDir: opts.paths.projectTaskGraphs }),
+      sessionPath: path7.join(opts.paths.projectDir, "sdd-wizard-session.json")
+    }),
+    runInterviewTurn: (prompt) => runIsolatedTurn(prompt, "Spec Architect"),
+    startRun: async (driver, { parallelSlots, defaultModel, defaultProvider, fallbackModels }) => {
+      const graph = driver.getGraph();
+      const tracker = driver.getTracker();
+      if (!graph || !tracker) {
+        throw new Error("No task graph to run \u2014 finish the interview first.");
+      }
+      let worktrees;
+      if (process.env["WRONGSTACK_SDD_WORKTREES"] !== "0") {
+        const inGit = spawnSync2("git", ["rev-parse", "--is-inside-work-tree"], {
+          cwd: opts.projectRoot,
+          encoding: "utf8",
+          windowsHide: true
+        }).stdout?.trim() === "true";
+        if (inGit) worktrees = new WorktreeManager2({ projectRoot: opts.projectRoot, events: opts.events });
+      }
+      const boardStore = new SddBoardStore2({ baseDir: opts.paths.projectSddBoards });
+      const verifyTask = makeCommandVerifier();
+      const superviseFailure = opts.brain ? new SddSupervisor({
+        brain: opts.brain,
+        // The run-level fallback chain (chosen in the wizard) doubles as the
+        // supervisor's reassign options — a `reassign` verdict rotates the
+        // worker model on retry. Empty/undefined → reassign option dropped.
+        reassignModels: fallbackModels,
+        // LLM auto-split: decompose a retry-exhausted task into smaller
+        // sub-tasks on an isolated read-only turn. Heavily validated +
+        // bounded; an empty result degrades the split into a retry.
+        generateSubtasks: makeLlmSubtaskGenerator({
+          run: (prompt) => runIsolatedTurn(prompt, "Task Splitter")
+        }),
+        // The standalone brain is a tiered policy→LLM arbiter with NO
+        // human-escalation wrapper (see index.ts), so it never blocks on a
+        // human prompt — an unresolved verdict degrades to a bounded retry.
+        // Safe to let the LLM layer actually pick reassign/split.
+        requestLlmVerdict: true
+      }).superviseFailure : void 0;
+      const handle = startSddRun({
+        tracker,
+        graph,
+        agent: opts.agent,
+        projectRoot: opts.projectRoot,
+        events: opts.events,
+        subagentFactory: opts.subagentFactory,
+        worktrees,
+        boardStore,
+        registry,
+        parallelSlots,
+        defaultModel,
+        defaultProvider,
+        fallbackModels,
+        verifyTask,
+        superviseFailure
+      });
+      void handle.completion.catch(() => {
+      });
+      return { runId: handle.runId };
+    }
+  };
+}
+
+// src/server/sdd-wizard-routes.ts
+async function handleSddWizardRoute(_ws, msg, handlers) {
+  if (!(msg.type.startsWith("sdd.spec.") || msg.type.startsWith("sdd.run."))) return false;
+  await handlers.handleMessage(msg);
+  return true;
+}
+
 // src/server/collaboration-ws-handler.ts
 import { randomUUID } from "crypto";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
@@ -3996,16 +4644,16 @@ var CollaborationWebSocketHandler = class {
 };
 
 // src/server/projects-manifest.ts
-import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as fs6 from "fs/promises";
+import * as path8 from "path";
 import { projectSlug } from "@wrongstack/core";
 function projectsJsonPath(globalConfigPath) {
-  const base = path6.dirname(globalConfigPath);
-  return path6.join(base, "projects.json");
+  const base = path8.dirname(globalConfigPath);
+  return path8.join(base, "projects.json");
 }
 async function loadManifest(globalConfigPath) {
   try {
-    const raw = await fs5.readFile(projectsJsonPath(globalConfigPath), "utf8");
+    const raw = await fs6.readFile(projectsJsonPath(globalConfigPath), "utf8");
     const parsed = JSON.parse(raw);
     return { projects: parsed.projects ?? [] };
   } catch {
@@ -4014,16 +4662,16 @@ async function loadManifest(globalConfigPath) {
 }
 async function saveManifest(manifest, globalConfigPath) {
   const file = projectsJsonPath(globalConfigPath);
-  await fs5.mkdir(path6.dirname(file), { recursive: true });
-  await fs5.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
+  await fs6.mkdir(path8.dirname(file), { recursive: true });
+  await fs6.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
 }
 function generateProjectSlug(rootPath) {
   return projectSlug(rootPath);
 }
 async function ensureProjectDataDir(slug, globalConfigPath) {
-  const base = path6.dirname(globalConfigPath);
-  const dir = path6.join(base, "projects", slug);
-  await fs5.mkdir(dir, { recursive: true });
+  const base = path8.dirname(globalConfigPath);
+  const dir = path8.join(base, "projects", slug);
+  await fs6.mkdir(dir, { recursive: true });
   return dir;
 }
 
@@ -4449,14 +5097,14 @@ function registerShutdownHandlers(res) {
 
 // src/server/instance-registry.ts
 import * as os from "os";
-import * as path7 from "path";
-import * as fs6 from "fs/promises";
+import * as path9 from "path";
+import * as fs7 from "fs/promises";
 import { atomicWrite as atomicWrite3 } from "@wrongstack/core";
 function defaultBaseDir() {
-  return path7.join(os.homedir(), ".wrongstack");
+  return path9.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path7.join(baseDir, "webui-instances.json");
+  return path9.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -4469,7 +5117,7 @@ function isPidAlive(pid) {
 }
 async function load(file) {
   try {
-    const raw = await fs6.readFile(file, "utf8");
+    const raw = await fs7.readFile(file, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed?.version === 1 && Array.isArray(parsed.instances)) {
       return parsed;
@@ -4578,9 +5226,10 @@ function openBrowser(url, platform = process.platform) {
     if (child.pid) {
       try {
         import("@wrongstack/tools").then(({ getProcessRegistry }) => {
+          const pid = child.pid;
+          if (pid === void 0) return;
           getProcessRegistry().register({
-            // biome-ignore lint/style/noNonNullAssertion: pid always present after spawn
-            pid: child.pid,
+            pid,
             name: "browser",
             command: `${command} ${args.join(" ")}`,
             startedAt: Date.now(),
@@ -4588,7 +5237,7 @@ function openBrowser(url, platform = process.platform) {
             protected: true
           });
           child.on("exit", () => {
-            getProcessRegistry().unregister(child.pid);
+            getProcessRegistry().unregister(pid);
           });
         }).catch(() => {
         });
@@ -4613,19 +5262,19 @@ function computeUsageCost(usage, rates) {
 }
 
 // src/server/provider-handlers.ts
-import { DefaultSecretScrubber as DefaultSecretScrubber2 } from "@wrongstack/core";
+import { DefaultSecretScrubber } from "@wrongstack/core";
 import { probeLocalLlm } from "@wrongstack/runtime/probe";
 
 // src/server/provider-config-io.ts
-import * as fs7 from "fs/promises";
-import * as path8 from "path";
+import * as fs8 from "fs/promises";
+import * as path10 from "path";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core";
 import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
 import { DefaultSecretVault } from "@wrongstack/core";
 async function loadSavedProviders(configPath, vault) {
   let raw;
   try {
-    raw = await fs7.readFile(configPath, "utf8");
+    raw = await fs8.readFile(configPath, "utf8");
   } catch {
     return {};
   }
@@ -4642,7 +5291,7 @@ async function saveProviders(configPath, vault, providers) {
   let raw;
   let fileExists = true;
   try {
-    raw = await fs7.readFile(configPath, "utf8");
+    raw = await fs8.readFile(configPath, "utf8");
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw new Error(
@@ -4791,7 +5440,7 @@ function projectSavedProviders(providers) {
     return view;
   });
 }
-var probeScrubber = new DefaultSecretScrubber2();
+var probeScrubber = new DefaultSecretScrubber();
 function createProviderHandlers(deps2) {
   const { globalConfigPath, vault, broadcast: broadcast2, clients } = deps2;
   let configWriteLock = deps2.getConfigWriteLock();
@@ -4816,7 +5465,10 @@ function createProviderHandlers(deps2) {
     try {
       const providers = await loadConfigProviders();
       const result = upsertKey(providers, providerId, label, apiKey, (/* @__PURE__ */ new Date()).toISOString());
-      if (result.ok) await saveConfigProviders(providers);
+      if (result.ok) {
+        await saveConfigProviders(providers);
+        broadcastSaved(providers);
+      }
       sendResult2(ws, result.ok, result.message);
     } catch (err) {
       sendResult2(ws, false, errMessage(err));
@@ -4826,7 +5478,10 @@ function createProviderHandlers(deps2) {
     try {
       const providers = await loadConfigProviders();
       const result = deleteKey(providers, providerId, label);
-      if (result.ok) await saveConfigProviders(providers);
+      if (result.ok) {
+        await saveConfigProviders(providers);
+        broadcastSaved(providers);
+      }
       sendResult2(ws, result.ok, result.message);
     } catch (err) {
       sendResult2(ws, false, errMessage(err));
@@ -4836,7 +5491,10 @@ function createProviderHandlers(deps2) {
     try {
       const providers = await loadConfigProviders();
       const result = setActiveKey(providers, providerId, label);
-      if (result.ok) await saveConfigProviders(providers);
+      if (result.ok) {
+        await saveConfigProviders(providers);
+        broadcastSaved(providers);
+      }
       sendResult2(ws, result.ok, result.message);
     } catch (err) {
       sendResult2(ws, false, errMessage(err));
@@ -4846,11 +5504,13 @@ function createProviderHandlers(deps2) {
     try {
       const providers = await loadConfigProviders();
       const result = addProvider(providers, payload, (/* @__PURE__ */ new Date()).toISOString());
-      if (result.ok) await saveConfigProviders(providers);
+      if (result.ok) {
+        await saveConfigProviders(providers);
+        broadcastSaved(providers);
+      }
       sendResult2(ws, result.ok, result.message);
       if (result.ok) {
         console.log(`[WebUI] Provider "${payload.id}" added via provider.add`);
-        broadcastSaved(providers);
       }
     } catch (err) {
       sendResult2(ws, false, errMessage(err));
@@ -4860,7 +5520,10 @@ function createProviderHandlers(deps2) {
     try {
       const providers = await loadConfigProviders();
       const result = removeProvider(providers, providerId);
-      if (result.ok) await saveConfigProviders(providers);
+      if (result.ok) {
+        await saveConfigProviders(providers);
+        broadcastSaved(providers);
+      }
       sendResult2(ws, result.ok, result.message);
     } catch (err) {
       sendResult2(ws, false, errMessage(err));
@@ -4966,7 +5629,7 @@ function createProviderHandlers(deps2) {
 
 // src/server/mode-handlers.ts
 import {
-  DefaultSystemPromptBuilder as DefaultSystemPromptBuilder2
+  DefaultSystemPromptBuilder
 } from "@wrongstack/core";
 function createModeHandlers(ctx) {
   return {
@@ -5014,7 +5677,7 @@ function createModeHandlers(ctx) {
         }
         ctx.setModeId(id);
         const modePrompt = id === "default" ? "" : (await ctx.modeStore.getMode(id))?.prompt ?? "";
-        const freshBuilder = new DefaultSystemPromptBuilder2({
+        const freshBuilder = new DefaultSystemPromptBuilder({
           memoryStore: ctx.memoryStore,
           skillLoader: ctx.skillLoader,
           modeStore: ctx.modeStore,
@@ -5043,42 +5706,12 @@ function createModeHandlers(ctx) {
 
 // src/server/project-handlers.ts
 import * as fs9 from "fs/promises";
-import * as path10 from "path";
+import * as path11 from "path";
 import {
-  DefaultSessionStore as DefaultSessionStore2,
-  DefaultSystemPromptBuilder as DefaultSystemPromptBuilder3,
+  DefaultSessionStore,
+  DefaultSystemPromptBuilder as DefaultSystemPromptBuilder2,
   getSessionRegistry
 } from "@wrongstack/core";
-
-// src/server/path-containment.ts
-import * as fs8 from "fs/promises";
-import * as path9 from "path";
-function isPathInside(root, target) {
-  const relative3 = path9.relative(root, target);
-  return relative3 === "" || !relative3.startsWith("..") && !path9.isAbsolute(relative3);
-}
-async function resolveWorkingDirInsideProject(projectRoot, inputPath) {
-  const resolved = path9.resolve(projectRoot, inputPath);
-  let stat3;
-  try {
-    stat3 = await fs8.stat(resolved);
-  } catch {
-    throw new Error(`Directory not found or not accessible: ${resolved}`);
-  }
-  if (!stat3.isDirectory()) {
-    throw new Error(`Directory not found or not accessible: ${resolved}`);
-  }
-  const [realProjectRoot, realResolved] = await Promise.all([
-    fs8.realpath(projectRoot),
-    fs8.realpath(resolved)
-  ]);
-  if (!isPathInside(realProjectRoot, realResolved)) {
-    throw new Error(`Path must stay inside the project root: ${projectRoot}`);
-  }
-  return resolved;
-}
-
-// src/server/project-handlers.ts
 function createProjectHandlers(ctx) {
   return {
     listProjects: async (ws) => {
@@ -5100,7 +5733,7 @@ function createProjectHandlers(ctx) {
       }
       const { root: addRoot, name: displayName } = parsed.value;
       try {
-        const resolved = path10.resolve(addRoot);
+        const resolved = path11.resolve(addRoot);
         await fs9.access(resolved);
         const stat3 = await fs9.stat(resolved);
         if (!stat3.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
@@ -5118,7 +5751,7 @@ function createProjectHandlers(ctx) {
           });
           return;
         }
-        const name2 = displayName?.trim() || path10.basename(resolved);
+        const name2 = displayName?.trim() || path11.basename(resolved);
         const slug = generateProjectSlug(resolved);
         await ensureProjectDataDir(slug, ctx.globalConfigPath);
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -5131,7 +5764,7 @@ function createProjectHandlers(ctx) {
       } catch (err) {
         send(ws, {
           type: "projects.added",
-          payload: { name: path10.basename(addRoot), root: addRoot, slug: "", message: errMessage(err) }
+          payload: { name: path11.basename(addRoot), root: addRoot, slug: "", message: errMessage(err) }
         });
       }
     },
@@ -5146,7 +5779,7 @@ function createProjectHandlers(ctx) {
       }
       const { root: selRoot, name: selName } = parsed.value;
       try {
-        const resolved = path10.resolve(selRoot);
+        const resolved = path11.resolve(selRoot);
         try {
           await fs9.access(resolved);
           const stat3 = await fs9.stat(resolved);
@@ -5156,7 +5789,7 @@ function createProjectHandlers(ctx) {
             type: "projects.selected",
             payload: {
               root: selRoot,
-              name: selName || path10.basename(selRoot),
+              name: selName || path11.basename(selRoot),
               message: `Cannot switch: ${errMessage(err)}`
             }
           });
@@ -5168,7 +5801,7 @@ function createProjectHandlers(ctx) {
           entry.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
           entry.lastWorkingDir = resolved;
         } else {
-          const name2 = selName?.trim() || path10.basename(resolved);
+          const name2 = selName?.trim() || path11.basename(resolved);
           const slug = generateProjectSlug(resolved);
           manifest.projects.push({
             name: name2,
@@ -5190,7 +5823,7 @@ function createProjectHandlers(ctx) {
         try {
           const modeId = ctx.getModeId();
           const switchMode = modeId === "default" ? void 0 : await ctx.modeStore.getMode(modeId);
-          const switchBuilder = new DefaultSystemPromptBuilder3({
+          const switchBuilder = new DefaultSystemPromptBuilder2({
             memoryStore: ctx.memoryStore,
             skillLoader: ctx.skillLoader,
             modeStore: ctx.modeStore,
@@ -5207,14 +5840,14 @@ function createProjectHandlers(ctx) {
           });
         } catch {
         }
-        const newSessionsDir = path10.join(
-          path10.dirname(ctx.globalConfigPath),
+        const newSessionsDir = path11.join(
+          path11.dirname(ctx.globalConfigPath),
           "projects",
           switchSlug,
           "sessions"
         );
         await fs9.mkdir(newSessionsDir, { recursive: true });
-        const newSessionStore = new DefaultSessionStore2({ dir: newSessionsDir });
+        const newSessionStore = new DefaultSessionStore({ dir: newSessionsDir });
         const oldSession = ctx.getSession();
         const oldSessionId = oldSession.id;
         try {
@@ -5247,7 +5880,7 @@ function createProjectHandlers(ctx) {
             sessionId: newSession.id,
             projectSlug: switchSlug,
             projectRoot: resolved,
-            projectName: path10.basename(resolved),
+            projectName: path11.basename(resolved),
             workingDir: resolved,
             clientType: "webui",
             pid: process.pid,
@@ -5259,8 +5892,8 @@ function createProjectHandlers(ctx) {
           type: "projects.selected",
           payload: {
             root: resolved,
-            name: selName || path10.basename(resolved),
-            message: `Switched to ${selName || path10.basename(resolved)}`
+            name: selName || path11.basename(resolved),
+            message: `Switched to ${selName || path11.basename(resolved)}`
           }
         });
         broadcast(ctx.clients, {
@@ -5280,7 +5913,7 @@ function createProjectHandlers(ctx) {
           type: "projects.selected",
           payload: {
             root: selRoot,
-            name: selName || path10.basename(selRoot),
+            name: selName || path11.basename(selRoot),
             message: errMessage(err)
           }
         });
@@ -5311,7 +5944,7 @@ function createProjectHandlers(ctx) {
 }
 
 // src/server/session-handlers.ts
-import * as path11 from "path";
+import * as path12 from "path";
 import {
   DEFAULT_CONTEXT_WINDOW_MODE_ID,
   repairToolUseAdjacency,
@@ -5653,7 +6286,7 @@ function createSessionHandlers(ctx) {
         const { DefaultSessionRewinder } = await import("@wrongstack/core");
         const projectRoot = ctx.getProjectRoot();
         const rewinder = new DefaultSessionRewinder(
-          path11.join(projectRoot, ".wrongstack", "sessions"),
+          path12.join(projectRoot, ".wrongstack", "sessions"),
           projectRoot
         );
         const checkpoints = await rewinder.listCheckpoints(ctx.getSession().id);
@@ -5668,7 +6301,7 @@ function createSessionHandlers(ctx) {
         const { DefaultSessionRewinder } = await import("@wrongstack/core");
         const projectRoot = ctx.getProjectRoot();
         const rewinder = new DefaultSessionRewinder(
-          path11.join(projectRoot, ".wrongstack", "sessions"),
+          path12.join(projectRoot, ".wrongstack", "sessions"),
           projectRoot
         );
         await rewinder.rewindToCheckpoint(ctx.getSession().id, checkpointIndex);
@@ -5911,6 +6544,22 @@ async function handleModeRoute(ws, msg, handlers) {
   }
 }
 
+// src/server/prefs-routes.ts
+async function handlePrefsRoute(ws, msg, handlers) {
+  switch (msg.type) {
+    case "prefs.get": {
+      await handlers.getPrefs(ws);
+      return true;
+    }
+    case "prefs.update": {
+      await handlers.updatePrefs(ws, msg.payload ?? {});
+      return true;
+    }
+    default:
+      return false;
+  }
+}
+
 // src/server/shell-git-routes.ts
 async function handleShellGitRoute(ws, msg, handlers) {
   switch (msg.type) {
@@ -5951,6 +6600,44 @@ async function handleMailboxRoute(ws, msg, handlers) {
   }
 }
 
+// src/server/mcp-routes.ts
+async function handleMcpRoute(ws, msg, handlers) {
+  switch (msg.type) {
+    case "mcp.list":
+      await handlers.list(ws, msg);
+      return true;
+    case "mcp.add":
+      await handlers.add(ws, msg);
+      return true;
+    case "mcp.update":
+      await handlers.update(ws, msg);
+      return true;
+    case "mcp.remove":
+      await handlers.remove(ws, msg);
+      return true;
+    case "mcp.enable":
+      await handlers.enable(ws, msg);
+      return true;
+    case "mcp.disable":
+      await handlers.disable(ws, msg);
+      return true;
+    case "mcp.sleep":
+      await handlers.sleep(ws, msg);
+      return true;
+    case "mcp.wake":
+      await handlers.wake(ws, msg);
+      return true;
+    case "mcp.restart":
+      await handlers.restart(ws, msg);
+      return true;
+    case "mcp.discover":
+      await handlers.discover(ws, msg);
+      return true;
+    default:
+      return false;
+  }
+}
+
 // src/server/brain-routes.ts
 async function handleBrainRoute(ws, msg, handlers) {
   switch (msg.type) {
@@ -5975,10 +6662,24 @@ async function handleAutoPhaseRoute(_ws, msg, handlers) {
   return true;
 }
 
+// src/server/specs-routes.ts
+async function handleSpecsRoute(_ws, msg, handlers) {
+  if (!msg.type.startsWith("specs.")) return false;
+  await handlers.handleMessage(msg);
+  return true;
+}
+
+// src/server/sdd-board-routes.ts
+async function handleSddBoardRoute(_ws, msg, handlers) {
+  if (!msg.type.startsWith("sdd.board.")) return false;
+  await handlers.handleMessage(msg);
+  return true;
+}
+
 // src/server/setup-events.ts
 import * as fs10 from "fs/promises";
 import { watch as fsWatch } from "fs";
-import * as path12 from "path";
+import * as path13 from "path";
 function setupEvents(deps2) {
   const { events, broadcast: broadcast2, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge, wpaths, watcherMetrics, onFleetBroadcaster } = deps2;
   const disposers = [];
@@ -6408,11 +7109,13 @@ function setupEvents(deps2) {
   events.on("provider.response", (e) => {
     if (e.usage?.input != null) {
       const maxCtx = context.provider.capabilities.maxContext;
-      const pct = maxCtx > 0 ? e.usage.input / maxCtx : 0;
+      const rawLoad = maxCtx > 0 ? e.usage.input / maxCtx : 0;
+      const load2 = Math.max(0, Math.min(1, rawLoad));
       const costUsd = context.tokenCounter.estimateCost().total;
       forwardSubagent("ctx_pct", {
         subagentId: "leader",
-        load: pct,
+        load: load2,
+        rawLoad,
         tokens: e.usage.input,
         maxContext: maxCtx,
         costUsd
@@ -6443,7 +7146,7 @@ function setupEvents(deps2) {
     if (wpaths?.projectStatus) {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
-        const dir = path12.dirname(statusFile);
+        const dir = path13.dirname(statusFile);
         await fs10.mkdir(dir, { recursive: true });
         await fs10.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
       } catch (err) {
@@ -6452,7 +7155,7 @@ function setupEvents(deps2) {
     }
   });
   if (wpaths?.projectStatus && wpaths.configDir) {
-    const projectsDir = path12.join(wpaths.configDir, "projects");
+    const projectsDir = path13.join(wpaths.configDir, "projects");
     const knownProjectHashes = /* @__PURE__ */ new Set();
     const debounceTimers = /* @__PURE__ */ new Map();
     const DEBOUNCE_MS = 150;
@@ -6479,7 +7182,7 @@ function setupEvents(deps2) {
       );
     };
     const metricsInterval = setInterval(logWatcherMetrics, 6e4);
-    const broadcastStatus = (projectHash2, statusData, actualDelayMs) => {
+    const broadcastStatus = (_projectHash, statusData, actualDelayMs) => {
       broadcast2(clients, { type: "client.status_update", payload: statusData });
       if (watcherMetrics) {
         watcherMetrics.broadcastsSent++;
@@ -6520,9 +7223,9 @@ function setupEvents(deps2) {
           if (eventType === "change") {
             if (filename == null) return;
             if (watcherMetrics) watcherMetrics.fileChangesDetected++;
-            const targetFile = path12.join(projectsDir, String(filename));
+            const targetFile = path13.join(projectsDir, String(filename));
             if (targetFile.endsWith("status.json")) {
-              const projectHash2 = path12.basename(path12.dirname(targetFile));
+              const projectHash2 = path13.basename(path13.dirname(targetFile));
               if (knownProjectHashes.size > 0 && !knownProjectHashes.has(projectHash2)) {
                 return;
               }
@@ -6580,7 +7283,7 @@ function setupEvents(deps2) {
       }
     });
   }
-  const globalRoot = globalConfigPath ? path12.dirname(globalConfigPath) : void 0;
+  const globalRoot = globalConfigPath ? path13.dirname(globalConfigPath) : void 0;
   if (globalRoot) {
     const broadcastSessions = async () => {
       try {
@@ -6654,10 +7357,10 @@ function setupEvents(deps2) {
 // src/server/custom-context-modes.ts
 import { listContextWindowModes, atomicWrite as atomicWrite5 } from "@wrongstack/core";
 import * as fs11 from "fs/promises";
-import * as path13 from "path";
+import * as path14 from "path";
 var STORE_FILENAME = "custom-context-modes.json";
 function storePath(wrongstackDir) {
-  return path13.join(wrongstackDir, STORE_FILENAME);
+  return path14.join(wrongstackDir, STORE_FILENAME);
 }
 var BUILTIN_IDS = /* @__PURE__ */ new Set(["balanced", "frugal", "deep", "archival"]);
 function createCustomModeStore(wrongstackDir) {
@@ -6789,12 +7492,12 @@ function createEternalSubscription(subscribe, broadcast2, clientsRef) {
 
 // src/server/shell-open.ts
 import * as fs12 from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 import { spawn as spawn2 } from "child_process";
 var METACHAR_REGEX = /[&|<>^"'`\n\r]/;
 async function handleShellOpen(req, logger) {
   try {
-    const resolved = path14.resolve(req.path);
+    const resolved = path15.resolve(req.path);
     await fs12.access(resolved);
     if (METACHAR_REGEX.test(resolved)) {
       return { success: false, message: "Path contains unsupported characters." };
@@ -6904,15 +7607,15 @@ async function handleGitChanges(ws, projectRoot) {
         if (!m) continue;
         const added = m[1] === "-" ? 0 : Number(m[1]);
         const deleted = m[2] === "-" ? 0 : Number(m[2]);
-        let path16 = m[3] ?? "";
-        if (path16 === "") {
+        let path17 = m[3] ?? "";
+        if (path17 === "") {
           i += 1;
-          path16 = parts[i + 1] ?? parts[i] ?? "";
+          path17 = parts[i + 1] ?? parts[i] ?? "";
           i += 1;
         }
-        if (!path16) continue;
-        const prev = counts.get(path16) ?? { added: 0, deleted: 0 };
-        counts.set(path16, { added: prev.added + added, deleted: prev.deleted + deleted });
+        if (!path17) continue;
+        const prev = counts.get(path17) ?? { added: 0, deleted: 0 };
+        counts.set(path17, { added: prev.added + added, deleted: prev.deleted + deleted });
       }
     };
     parseNumstat(unstagedNumstat);
@@ -6924,7 +7627,7 @@ async function handleGitChanges(ws, projectRoot) {
       if (!rec || rec.length < 3) continue;
       const x = rec[0] ?? " ";
       const y = rec[1] ?? " ";
-      const path16 = rec.slice(3);
+      const path17 = rec.slice(3);
       const isRename = x === "R" || x === "C" || y === "R" || y === "C";
       if (isRename) i += 1;
       let status;
@@ -6936,13 +7639,13 @@ async function handleGitChanges(ws, projectRoot) {
       else if (x === "D" || y === "D") status = "D";
       else status = "M";
       const staged = x !== " " && x !== "?";
-      let added = counts.get(path16)?.added ?? 0;
-      let deleted = counts.get(path16)?.deleted ?? 0;
+      let added = counts.get(path17)?.added ?? 0;
+      let deleted = counts.get(path17)?.deleted ?? 0;
       if (status === "?") {
         added = 0;
         deleted = 0;
       }
-      files.push({ path: path16, status, added, deleted, staged });
+      files.push({ path: path17, status, added, deleted, staged });
     }
     send(ws, { type: "git.changes", payload: { files } });
   } catch (err) {
@@ -6953,21 +7656,21 @@ async function handleGitChanges(ws, projectRoot) {
   }
 }
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
-async function handleGitDiff(ws, projectRoot, path16) {
+async function handleGitDiff(ws, projectRoot, path17) {
   const cwd = projectRoot || void 0;
-  const reply = (extra) => send(ws, { type: "git.diff", payload: { path: path16, ...extra } });
-  if (!path16 || path16.includes("\0") || path16.includes("..") || nodePath.isAbsolute(path16)) {
+  const reply = (extra) => send(ws, { type: "git.diff", payload: { path: path17, ...extra } });
+  if (!path17 || path17.includes("\0") || path17.includes("..") || nodePath.isAbsolute(path17)) {
     reply({ oldText: "", newText: "", error: "invalid path" });
     return;
   }
   try {
     const git = makeGit(cwd);
     const { readFile: readFile9 } = await import("fs/promises");
-    const { join: join11 } = await import("path");
-    const oldText = await git(["show", `HEAD:${path16}`]);
+    const { join: join12 } = await import("path");
+    const oldText = await git(["show", `HEAD:${path17}`]);
     let newText = "";
     try {
-      const abs = cwd ? join11(cwd, path16) : path16;
+      const abs = cwd ? join12(cwd, path17) : path17;
       const buf = await readFile9(abs);
       if (buf.includes(0)) {
         reply({ oldText: "", newText: "", binary: true });
@@ -7063,6 +7766,7 @@ async function handleGoalGet(projectRoot, broadcast2) {
 
 // src/server/index.ts
 async function startWebUI(opts = {}) {
+  ensureSessionShell();
   const requestedWsPort = opts.wsPort ?? 3457;
   const wsHost = opts.wsHost ?? "127.0.0.1";
   const requestedHttpPort = Number.parseInt(process.env["PORT"] ?? "3456", 10);
@@ -7144,7 +7848,7 @@ async function startWebUI(opts = {}) {
     ttlSeconds: 24 * 3600
   });
   const container = createDefaultContainer({ config, wpaths, logger, modelsRegistry });
-  const configStore = opts.services?.configStore ?? container.resolve(TOKENS2.ConfigStore);
+  const configStore = opts.services?.configStore ?? container.resolve(TOKENS.ConfigStore);
   const providerRegistry = new ProviderRegistry();
   try {
     const factories = await buildProviderFactoriesFromRegistry({
@@ -7166,7 +7870,7 @@ async function startWebUI(opts = {}) {
     r.registerAllOrThrow([...builtinToolsPack.tools ?? []], builtinToolsPack.name);
     return r;
   })();
-  const memoryStore = new DefaultMemoryStore2({ paths: wpaths });
+  const memoryStore = new DefaultMemoryStore({ paths: wpaths });
   if (config.features.memory) {
     toolRegistry.register(rememberTool(memoryStore));
     toolRegistry.register(forgetTool(memoryStore));
@@ -7178,6 +7882,8 @@ async function startWebUI(opts = {}) {
   toolRegistry.register(makeMailboxTool({ projectDir: wpaths.projectDir, events }));
   toolRegistry.register(makeMailSendTool({ projectDir: wpaths.projectDir, events }));
   toolRegistry.register(makeMailInboxTool({ projectDir: wpaths.projectDir, events }));
+  applyToolDescriptionModes(toolRegistry, config.tools?.descriptionMode);
+  configureExecPolicy(config.tools?.exec ?? {});
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const mcpRegistry = new MCPRegistry({
     toolRegistry,
@@ -7194,7 +7900,7 @@ async function startWebUI(opts = {}) {
       });
     }
   }
-  let sessionStore = opts.services?.session ?? new DefaultSessionStore3({ dir: wpaths.projectSessions });
+  let sessionStore = opts.services?.session ?? new DefaultSessionStore2({ dir: wpaths.projectSessions });
   if (!opts.services?.session) {
     sessionStore.prune(DEFAULT_SESSION_PRUNE_DAYS).then((count) => {
       if (count > 0) logger.info(`Pruned ${count} old session${count === 1 ? "" : "s"}.`);
@@ -7221,7 +7927,7 @@ async function startWebUI(opts = {}) {
       sessionId: session.id,
       projectSlug: wpaths.projectSlug,
       projectRoot,
-      projectName: path15.basename(projectRoot),
+      projectName: path16.basename(projectRoot),
       workingDir,
       clientType: "webui",
       pid: process.pid,
@@ -7241,7 +7947,7 @@ async function startWebUI(opts = {}) {
       const hqTelemetry = createHqPublisherFromEnv({
         clientKind: "webui",
         projectRoot,
-        projectName: path15.basename(projectRoot),
+        projectName: path16.basename(projectRoot),
         appConfig: config,
         socketFactory: (url) => new WebSocket2(url)
       });
@@ -7253,7 +7959,7 @@ async function startWebUI(opts = {}) {
           events,
           sessionId: session.id,
           projectRoot,
-          projectName: path15.basename(projectRoot),
+          projectName: path16.basename(projectRoot),
           globalRoot: wpaths.globalRoot,
           initialAgents: statusTracker?.getAgents(),
           startedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -7282,11 +7988,11 @@ async function startWebUI(opts = {}) {
     });
   } catch {
   }
-  const tokenCounter = new DefaultTokenCounter2({
+  const tokenCounter = new DefaultTokenCounter({
     registry: modelsRegistry,
     providerId: config.provider
   });
-  const modeStore = new DefaultModeStore2({ directory: wpaths.configDir });
+  const modeStore = new DefaultModeStore({ directory: wpaths.configDir });
   const activeMode = await modeStore.getActiveMode();
   let modeId = activeMode?.id ?? "default";
   const modePrompt = activeMode?.prompt ?? "";
@@ -7307,15 +8013,15 @@ async function startWebUI(opts = {}) {
   const modelCapabilitiesRef = {
     current: modelCapabilities
   };
-  const skillLoader = config.features.skills ? new DefaultSkillLoader2({ paths: wpaths }) : void 0;
+  const skillLoader = config.features.skills ? new DefaultSkillLoader({ paths: wpaths }) : void 0;
   const skillInstaller = config.features.skills ? new SkillInstaller({
-    manifestPath: path15.join(wstackGlobalRoot2(), "installed-skills.json"),
-    projectSkillsDir: path15.join(projectRoot, ".wrongstack", "skills"),
-    globalSkillsDir: path15.join(wstackGlobalRoot2(), "skills"),
+    manifestPath: path16.join(wstackGlobalRoot2(), "installed-skills.json"),
+    projectSkillsDir: path16.join(projectRoot, ".wrongstack", "skills"),
+    globalSkillsDir: path16.join(wstackGlobalRoot2(), "skills"),
     projectHash: projectHash(projectRoot),
     skillLoader
   }) : void 0;
-  const systemPromptBuilder = new DefaultSystemPromptBuilder4({
+  const systemPromptBuilder = new DefaultSystemPromptBuilder3({
     memoryStore,
     skillLoader,
     modeStore,
@@ -7415,6 +8121,8 @@ async function startWebUI(opts = {}) {
     context.meta["enhanceDelayMs"] = autonomyCfg["enhanceDelayMs"] ?? 6e4;
     context.meta["enhanceLanguage"] = autonomyCfg["enhanceLanguage"] ?? "original";
     context.meta["nextPrediction"] = config.nextPrediction ?? false;
+    context.meta["fallbackModels"] = config.fallbackModels ?? [];
+    context.meta["fallbackAuto"] = config.fallbackAuto !== false;
     context.meta["featureMcp"] = config.features.mcp !== false;
     context.meta["featurePlugins"] = config.features.plugins !== false;
     context.meta["featureMemory"] = config.features.memory !== false;
@@ -7472,7 +8180,9 @@ async function startWebUI(opts = {}) {
     "reasoningMode",
     "reasoningEffort",
     "reasoningPreserve",
-    "cacheTtl"
+    "cacheTtl",
+    "fallbackModels",
+    "fallbackAuto"
   ];
   const prefSnapshot = () => {
     const snapshot = {};
@@ -7503,6 +8213,8 @@ async function startWebUI(opts = {}) {
       if (typeof payload["enhanceLanguage"] === "string") setAutonomy("enhanceLanguage", payload["enhanceLanguage"]);
       if (autonomyTouched) decrypted.autonomy = autonomyCfg;
       if (typeof payload["nextPrediction"] === "boolean") decrypted.nextPrediction = payload["nextPrediction"];
+      if (Array.isArray(payload["fallbackModels"])) decrypted.fallbackModels = payload["fallbackModels"];
+      if (typeof payload["fallbackAuto"] === "boolean") decrypted.fallbackAuto = payload["fallbackAuto"];
       const FEATURE_MAP = {
         featureMcp: "mcp",
         featurePlugins: "plugins",
@@ -7599,7 +8311,7 @@ async function startWebUI(opts = {}) {
     projectRoot,
     logger
   });
-  const compactor = createStrategyCompactor2({
+  const compactor = createStrategyCompactor({
     strategy: config.context?.strategy,
     preserveK: config.context?.preserveK ?? 10,
     eliseThreshold: config.context?.eliseThreshold ?? 2e3,
@@ -7675,9 +8387,9 @@ async function startWebUI(opts = {}) {
       maxContext: newMaxContext
     });
   }
-  const secretScrubber = container.resolve(TOKENS2.SecretScrubber);
-  const renderer = container.has(TOKENS2.Renderer) ? container.resolve(TOKENS2.Renderer) : void 0;
-  const permissionPolicy = container.resolve(TOKENS2.PermissionPolicy);
+  const secretScrubber = container.resolve(TOKENS.SecretScrubber);
+  const renderer = container.has(TOKENS.Renderer) ? container.resolve(TOKENS.Renderer) : void 0;
+  const permissionPolicy = container.resolve(TOKENS.PermissionPolicy);
   const toolExecutor = new ToolExecutor(toolRegistry, {
     permissionPolicy,
     secretScrubber,
@@ -7720,7 +8432,7 @@ async function startWebUI(opts = {}) {
     }),
     events
   );
-  container.bind(TOKENS2.BrainArbiter, () => brain);
+  container.bind(TOKENS.BrainArbiter, () => brain);
   const brainMailbox = new GlobalMailbox2(wpaths.projectDir, events);
   const brainMonitor = new BrainMonitor({
     events,
@@ -7783,6 +8495,29 @@ async function startWebUI(opts = {}) {
     events,
     projectRoot
   );
+  const specsHandler = new SpecsWebSocketHandler(wpaths.projectSpecs, wpaths.projectTaskGraphs);
+  const sddBoardHandler = new SddBoardWebSocketHandler(wpaths.projectSddBoards);
+  const sddWizardHandler = new SddWizardWebSocketHandler(
+    buildSddWizardDeps({
+      agent,
+      events,
+      projectRoot,
+      brain,
+      subagentFactory: makeLightSubagentFactory({
+        container,
+        providerRegistry,
+        toolRegistry,
+        session,
+        projectRoot
+      }),
+      paths: {
+        projectSpecs: wpaths.projectSpecs,
+        projectTaskGraphs: wpaths.projectTaskGraphs,
+        projectSddBoards: wpaths.projectSddBoards,
+        projectDir: wpaths.projectDir
+      }
+    })
+  );
   const worktreeHandler = new WorktreeWebSocketHandler(events, logger);
   const terminalHandler = new TerminalWebSocketHandler(() => workingDir, logger);
   const collabHandler = new CollaborationWebSocketHandler(
@@ -7822,7 +8557,7 @@ async function startWebUI(opts = {}) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path15.basename(projectRoot) || projectRoot,
+      projectName: path16.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: workingDir,
       mode: modeId,
@@ -7914,6 +8649,9 @@ async function startWebUI(opts = {}) {
       }));
     });
     autoPhaseHandler.addClient(ws);
+    specsHandler.addClient(ws);
+    sddBoardHandler.addClient(ws);
+    sddWizardHandler.addClient(ws);
     worktreeHandler.addClient(ws);
     collabHandler.addClient(ws);
     terminalHandler.addClient(ws);
@@ -8038,21 +8776,21 @@ async function startWebUI(opts = {}) {
     });
   }
   async function touchProjectEntry(root, workDir) {
-    const resolved = path15.resolve(root);
+    const resolved = path16.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = manifest.projects.find((p) => path15.resolve(p.root) === resolved);
+    const existing = manifest.projects.find((p) => path16.resolve(p.root) === resolved);
     if (existing) {
       existing.lastSeen = now;
-      if (workDir) existing.lastWorkingDir = path15.resolve(workDir);
+      if (workDir) existing.lastWorkingDir = path16.resolve(workDir);
     } else {
       manifest.projects.push({
-        name: path15.basename(resolved),
+        name: path16.basename(resolved),
         root: resolved,
         slug: generateProjectSlug(resolved),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: workDir ? path15.resolve(workDir) : void 0
+        lastWorkingDir: workDir ? path16.resolve(workDir) : void 0
       });
     }
     await saveManifest(manifest, globalConfigPath);
@@ -8074,19 +8812,29 @@ async function startWebUI(opts = {}) {
   let sessionRoutes;
   let projectRoutes;
   let modeRoutes;
+  let prefsRoutes;
   let shellGitRoutes;
   let mailboxRoutes;
+  let mcpRoutes;
   let brainRoutes;
   let autoPhaseRoutes;
+  let specsRoutes;
+  let sddBoardRoutes;
+  let sddWizardRoutes;
   async function handleMessage(ws, _client, msg) {
     if (await handleProviderRoute(ws, msg, providerRoutes)) return;
     if (await handleSessionRoute(ws, msg, sessionRoutes)) return;
     if (await handleProjectRoute(ws, msg, projectRoutes)) return;
     if (await handleModeRoute(ws, msg, modeRoutes)) return;
+    if (await handlePrefsRoute(ws, msg, prefsRoutes)) return;
     if (await handleShellGitRoute(ws, msg, shellGitRoutes)) return;
     if (await handleMailboxRoute(ws, msg, mailboxRoutes)) return;
+    if (await handleMcpRoute(ws, msg, mcpRoutes)) return;
     if (await handleBrainRoute(ws, msg, brainRoutes)) return;
     if (await handleAutoPhaseRoute(ws, msg, autoPhaseRoutes)) return;
+    if (await handleSpecsRoute(ws, msg, specsRoutes)) return;
+    if (await handleSddBoardRoute(ws, msg, sddBoardRoutes)) return;
+    if (await handleSddWizardRoute(ws, msg, sddWizardRoutes)) return;
     switch (msg.type) {
       // Collaboration messages short-circuit the user/agent flow.
       // They don't touch runLock, the agent loop, or the message queue —
@@ -8192,27 +8940,31 @@ async function startWebUI(opts = {}) {
       case "memory.forget":
         return handleMemoryForget(ws, msg, memoryStore);
       // ── MCP operations — delegated to shared handlers (mcp-handlers.ts),
-      // backed by the live MCPRegistry constructed above. ──
+      // backed by the live MCPRegistry constructed above. Routed via
+      // handleMcpRoute (see mcpRoutes = { ... } below). These case arms
+      // are unreachable but left as tripwires for any future regression
+      // where the route chain stops claiming 'mcp.*'. If you see one
+      // fire, fix the dispatch order in the handleMessage chain above.
       case "mcp.list":
-        return handleMcpList(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.list \u2014 check chain order");
       case "mcp.add":
-        return handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry);
-      case "mcp.remove":
-        return handleMcpRemove(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.add \u2014 check chain order");
       case "mcp.update":
-        return handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry);
-      case "mcp.wake":
-        return handleMcpWake(ws, msg, globalConfigPath, mcpRegistry);
-      case "mcp.sleep":
-        return handleMcpSleep(ws, msg, globalConfigPath, mcpRegistry);
-      case "mcp.discover":
-        return handleMcpDiscover(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.update \u2014 check chain order");
+      case "mcp.remove":
+        throw new Error("handleMcpRoute did not claim mcp.remove \u2014 check chain order");
       case "mcp.enable":
-        return handleMcpEnable(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.enable \u2014 check chain order");
       case "mcp.disable":
-        return handleMcpDisable(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.disable \u2014 check chain order");
+      case "mcp.sleep":
+        throw new Error("handleMcpRoute did not claim mcp.sleep \u2014 check chain order");
+      case "mcp.wake":
+        throw new Error("handleMcpRoute did not claim mcp.wake \u2014 check chain order");
       case "mcp.restart":
-        return handleMcpRestart(ws, msg, globalConfigPath, mcpRegistry);
+        throw new Error("handleMcpRoute did not claim mcp.restart \u2014 check chain order");
+      case "mcp.discover":
+        throw new Error("handleMcpRoute did not claim mcp.discover \u2014 check chain order");
       // Skills — full request→response cycle lives in skills-handlers.ts
       // (shared with the CLI's embedded server). skillsCtx is the closed-over
       // loader/installer/projectRoot the handlers need.
@@ -8360,49 +9112,11 @@ async function startWebUI(opts = {}) {
         break;
       }
       case "prefs.update": {
-        const parsed = validatePrefsUpdatePayload(msg.payload);
-        if (!parsed.ok) {
-          sendResult2(ws, false, parsed.message);
-          break;
-        }
-        const payload = parsed.value.prefs;
-        for (const [key, val] of Object.entries(payload)) {
-          context.meta[key] = val;
-        }
-        void persistPrefsToConfig(payload);
-        if (typeof payload["yolo"] === "boolean") {
-          permissionPolicy.setYolo?.(payload["yolo"]);
-        }
-        if (typeof payload["featureMcp"] === "boolean")
-          config.features.mcp = payload["featureMcp"];
-        if (typeof payload["featurePlugins"] === "boolean")
-          config.features.plugins = payload["featurePlugins"];
-        if (typeof payload["featureMemory"] === "boolean")
-          config.features.memory = payload["featureMemory"];
-        if (typeof payload["featureSkills"] === "boolean")
-          config.features.skills = payload["featureSkills"];
-        if (typeof payload["featureModelsRegistry"] === "boolean")
-          config.features.modelsRegistry = payload["featureModelsRegistry"];
-        if (typeof payload["contextAutoCompact"] === "boolean") {
-          if (payload["contextAutoCompact"] && autoCompactor) {
-            pipelines.contextWindow.remove("AutoCompaction", { optional: true });
-            pipelines.contextWindow.use({ name: "AutoCompaction", handler: autoCompactor.handler() });
-          } else {
-            pipelines.contextWindow.remove("AutoCompaction", { optional: true });
-          }
-        }
-        if (typeof payload["logLevel"] === "string") {
-          const valid = ["debug", "info", "warn", "error"];
-          if (valid.includes(payload["logLevel"])) {
-            logger.level = payload["logLevel"];
-          }
-        }
-        broadcast(clients, { type: "prefs.updated", payload: prefSnapshot() });
-        break;
+        void ws;
+        throw new Error("handlePrefsRoute did not claim prefs.update \u2014 check chain order");
       }
       case "prefs.get": {
-        send(ws, { type: "prefs.updated", payload: prefSnapshot() });
-        break;
+        throw new Error("handlePrefsRoute did not claim prefs.get \u2014 check chain order");
       }
       default:
         send(ws, {
@@ -8445,22 +9159,7 @@ async function startWebUI(opts = {}) {
       const saved = await providerHandlers.loadConfigProviders();
       send(ws, {
         type: "providers.saved",
-        payload: {
-          providers: Object.entries(saved).map(([id, cfg]) => {
-            const keys = normalizeKeys(cfg);
-            return {
-              id,
-              family: cfg.family ?? id,
-              baseUrl: cfg.baseUrl,
-              apiKeys: keys.map((k) => ({
-                label: k.label,
-                maskedKey: maskedKey(k.apiKey),
-                isActive: k.label === cfg.activeKey,
-                createdAt: k.createdAt
-              }))
-            };
-          })
-        }
+        payload: { providers: projectSavedProviders(saved) }
       });
     },
     listProviderModels: async (ws, msg) => {
@@ -8638,6 +9337,55 @@ async function startWebUI(opts = {}) {
     },
     sessionStartPayload
   });
+  prefsRoutes = {
+    getPrefs: async (ws) => {
+      send(ws, { type: "prefs.updated", payload: prefSnapshot() });
+    },
+    updatePrefs: async (ws, msgPayload) => {
+      const parsed = validatePrefsUpdatePayload(msgPayload);
+      if (!parsed.ok) {
+        sendResult2(ws, false, parsed.message);
+        return;
+      }
+      const payload = parsed.value.prefs;
+      for (const [key, val] of Object.entries(payload)) {
+        context.meta[key] = val;
+      }
+      void persistPrefsToConfig(payload);
+      if (typeof payload["yolo"] === "boolean") {
+        permissionPolicy.setYolo?.(payload["yolo"]);
+      }
+      if (typeof payload["featureMcp"] === "boolean")
+        config.features.mcp = payload["featureMcp"];
+      if (typeof payload["featurePlugins"] === "boolean")
+        config.features.plugins = payload["featurePlugins"];
+      if (typeof payload["featureMemory"] === "boolean")
+        config.features.memory = payload["featureMemory"];
+      if (typeof payload["featureSkills"] === "boolean")
+        config.features.skills = payload["featureSkills"];
+      if (typeof payload["featureModelsRegistry"] === "boolean")
+        config.features.modelsRegistry = payload["featureModelsRegistry"];
+      if (Array.isArray(payload["fallbackModels"]))
+        config.fallbackModels = payload["fallbackModels"];
+      if (typeof payload["fallbackAuto"] === "boolean")
+        config.fallbackAuto = payload["fallbackAuto"];
+      if (typeof payload["contextAutoCompact"] === "boolean") {
+        if (payload["contextAutoCompact"] && autoCompactor) {
+          pipelines.contextWindow.remove("AutoCompaction", { optional: true });
+          pipelines.contextWindow.use({ name: "AutoCompaction", handler: autoCompactor.handler() });
+        } else {
+          pipelines.contextWindow.remove("AutoCompaction", { optional: true });
+        }
+      }
+      if (typeof payload["logLevel"] === "string") {
+        const valid = ["debug", "info", "warn", "error"];
+        if (valid.includes(payload["logLevel"])) {
+          logger.level = payload["logLevel"];
+        }
+      }
+      broadcast(clients, { type: "prefs.updated", payload: prefSnapshot() });
+    }
+  };
   shellGitRoutes = {
     gitInfo: async (ws) => {
       await handleGitInfo(ws, projectRoot);
@@ -8670,7 +9418,7 @@ async function startWebUI(opts = {}) {
         sendResult2(ws, false, parsed.message);
         return;
       }
-      return handleMailboxMessages(ws, { projectRoot, globalRoot: path15.dirname(globalConfigPath) }, parsed.value);
+      return handleMailboxMessages(ws, { projectRoot, globalRoot: path16.dirname(globalConfigPath) }, parsed.value);
     },
     agents: (ws, msg) => {
       const parsed = validateMailboxAgentsPayload(msg.payload);
@@ -8678,18 +9426,30 @@ async function startWebUI(opts = {}) {
         sendResult2(ws, false, parsed.message);
         return;
       }
-      return handleMailboxAgents(ws, { projectRoot, globalRoot: path15.dirname(globalConfigPath) }, parsed.value);
+      return handleMailboxAgents(ws, { projectRoot, globalRoot: path16.dirname(globalConfigPath) }, parsed.value);
     },
-    clear: (ws) => handleMailboxClear(ws, { projectRoot, globalRoot: path15.dirname(globalConfigPath) }),
+    clear: (ws) => handleMailboxClear(ws, { projectRoot, globalRoot: path16.dirname(globalConfigPath) }),
     purge: (ws, msg) => {
       const parsed = validateMailboxPurgePayload(msg.payload);
       if (!parsed.ok) {
         sendResult2(ws, false, parsed.message);
         return;
       }
-      return handleMailboxPurge(ws, { projectRoot, globalRoot: path15.dirname(globalConfigPath) }, parsed.value);
+      return handleMailboxPurge(ws, { projectRoot, globalRoot: path16.dirname(globalConfigPath) }, parsed.value);
     }
   };
+  mcpRoutes = {
+    list: (ws, msg) => handleMcpList(ws, msg, globalConfigPath, mcpRegistry),
+    add: (ws, msg) => handleMcpAdd(ws, msg, globalConfigPath, mcpRegistry),
+    update: (ws, msg) => handleMcpUpdate(ws, msg, globalConfigPath, mcpRegistry),
+    remove: (ws, msg) => handleMcpRemove(ws, msg, globalConfigPath, mcpRegistry),
+    enable: (ws, msg) => handleMcpEnable(ws, msg, globalConfigPath, mcpRegistry),
+    disable: (ws, msg) => handleMcpDisable(ws, msg, globalConfigPath, mcpRegistry),
+    sleep: (ws, msg) => handleMcpSleep(ws, msg, globalConfigPath, mcpRegistry),
+    wake: (ws, msg) => handleMcpWake(ws, msg, globalConfigPath, mcpRegistry),
+    restart: (ws, msg) => handleMcpRestart(ws, msg, globalConfigPath, mcpRegistry),
+    discover: (ws, msg) => handleMcpDiscover(ws, msg, globalConfigPath, mcpRegistry)
+  };
   brainRoutes = {
     status: (ws) => {
       send(ws, {
@@ -8734,6 +9494,15 @@ async function startWebUI(opts = {}) {
   autoPhaseRoutes = {
     handleMessage: (msg) => autoPhaseHandler.handleMessage(msg)
   };
+  specsRoutes = {
+    handleMessage: (msg) => specsHandler.handleMessage(msg)
+  };
+  sddBoardRoutes = {
+    handleMessage: (msg) => sddBoardHandler.handleMessage(msg)
+  };
+  sddWizardRoutes = {
+    handleMessage: (msg) => sddWizardHandler.handleMessage(msg)
+  };
   const watcherMetrics = {
     fileChangesDetected: 0,
     filesProcessed: 0,
@@ -8746,7 +9515,7 @@ async function startWebUI(opts = {}) {
   };
   const httpServer = createHttpServer({
     host: wsHost,
-    distDir: path15.resolve(import.meta.dirname, "../../dist"),
+    distDir: path16.resolve(import.meta.dirname, "../../dist"),
     wsPort,
     globalRoot: wpaths.globalRoot,
     apiToken: wsToken,
@@ -8755,7 +9524,7 @@ async function startWebUI(opts = {}) {
       void fleetBroadcast?.();
     }
   });
-  const registryBaseDir = path15.dirname(globalConfigPath);
+  const registryBaseDir = path16.dirname(globalConfigPath);
   httpServer.listen(httpPort, wsHost, () => {
     const openUrl = `http://${wsHost}:${httpPort}`;
     console.log(`[WebUI] HTTP server running on ${openUrl}`);
@@ -8767,7 +9536,7 @@ async function startWebUI(opts = {}) {
         wsPort,
         host: wsHost,
         projectRoot,
-        projectName: path15.basename(projectRoot) || projectRoot,
+        projectName: path16.basename(projectRoot) || projectRoot,
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         url: `http://${wsHost}:${httpPort}`
       },