@wrongstack/webui 0.272.2 → 0.273.0

package/dist/server/index.js

@@ -7,7 +7,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"];
@@ -29,13 +32,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 } };
 }
@@ -46,7 +58,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 } };
 }
@@ -58,10 +73,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 } };
 }
@@ -72,7 +93,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 } };
 }
@@ -98,7 +122,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) {
@@ -113,7 +140,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",
@@ -134,8 +169,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",
@@ -167,6 +204,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(", ")}`;
@@ -287,16 +327,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,
@@ -320,22 +369,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 = {
@@ -346,11 +407,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,
@@ -368,28 +435,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)) {
@@ -569,7 +639,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;
@@ -649,7 +719,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";
@@ -2812,6 +2882,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,
@@ -2856,7 +2927,8 @@ function createDefaultContainer(opts) {
     () => new DefaultErrorHandler(
       buildRecoveryStrategies({
         compactor: container.resolve(TOKENS.Compactor),
-        modelsRegistry
+        modelsRegistry,
+        getConfig: () => configStore.get()
       })
     )
   );
@@ -2943,6 +3015,7 @@ function patchConfig(config, updates) {
 import { spawnSync } from "child_process";
 import { toErrorMessage } from "@wrongstack/core/utils";
 import {
+  assignNickname,
   AutoPhasePlanner,
   PhaseGraphBuilder,
   PhaseOrchestrator,
@@ -2980,6 +3053,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);
@@ -3022,6 +3097,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) {
@@ -3149,6 +3247,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}
@@ -3164,6 +3269,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()) {
@@ -3207,23 +3317,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,
@@ -3236,7 +3330,31 @@ 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;
     return {
       title: this.graph.title,
@@ -3269,6 +3387,513 @@ 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 path6 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: path6.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/index.ts
+import { makeLightSubagentFactory } from "@wrongstack/runtime";
+
 // src/server/collaboration-ws-handler.ts
 import { randomUUID } from "crypto";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
@@ -3996,11 +4621,11 @@ var CollaborationWebSocketHandler = class {
 
 // src/server/projects-manifest.ts
 import * as fs5 from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 import { projectSlug } from "@wrongstack/core";
 function projectsJsonPath(globalConfigPath) {
-  const base = path6.dirname(globalConfigPath);
-  return path6.join(base, "projects.json");
+  const base = path7.dirname(globalConfigPath);
+  return path7.join(base, "projects.json");
 }
 async function loadManifest(globalConfigPath) {
   try {
@@ -4013,15 +4638,15 @@ async function loadManifest(globalConfigPath) {
 }
 async function saveManifest(manifest, globalConfigPath) {
   const file = projectsJsonPath(globalConfigPath);
-  await fs5.mkdir(path6.dirname(file), { recursive: true });
+  await fs5.mkdir(path7.dirname(file), { recursive: true });
   await fs5.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);
+  const base = path7.dirname(globalConfigPath);
+  const dir = path7.join(base, "projects", slug);
   await fs5.mkdir(dir, { recursive: true });
   return dir;
 }
@@ -4448,14 +5073,14 @@ function registerShutdownHandlers(res) {
 
 // src/server/instance-registry.ts
 import * as os from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 import * as fs6 from "fs/promises";
 import { atomicWrite as atomicWrite3 } from "@wrongstack/core";
 function defaultBaseDir() {
-  return path7.join(os.homedir(), ".wrongstack");
+  return path8.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path7.join(baseDir, "webui-instances.json");
+  return path8.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -4577,9 +5202,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(),
@@ -4587,7 +5213,7 @@ function openBrowser(url, platform = process.platform) {
             protected: true
           });
           child.on("exit", () => {
-            getProcessRegistry().unregister(child.pid);
+            getProcessRegistry().unregister(pid);
           });
         }).catch(() => {
         });
@@ -4617,7 +5243,7 @@ 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 path9 from "path";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core";
 import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
 import { DefaultSecretVault } from "@wrongstack/core";
@@ -4669,7 +5295,7 @@ async function saveProviders(configPath, vault, providers) {
   await atomicWrite4(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
 }
 function createProviderConfigIO(configPath) {
-  const keyFile = path8.join(path8.dirname(configPath), ".key");
+  const keyFile = path9.join(path9.dirname(configPath), ".key");
   const vault = new DefaultSecretVault({ keyFile });
   return {
     load: () => loadSavedProviders(configPath, vault),
@@ -4823,7 +5449,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));
@@ -4833,7 +5462,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));
@@ -4843,7 +5475,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));
@@ -4853,11 +5488,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));
@@ -4867,7 +5504,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));
@@ -5050,7 +5690,7 @@ 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,
@@ -5059,13 +5699,13 @@ import {
 
 // src/server/path-containment.ts
 import * as fs8 from "fs/promises";
-import * as path9 from "path";
+import * as path10 from "path";
 function isPathInside(root, target) {
-  const relative3 = path9.relative(root, target);
-  return relative3 === "" || !relative3.startsWith("..") && !path9.isAbsolute(relative3);
+  const relative3 = path10.relative(root, target);
+  return relative3 === "" || !relative3.startsWith("..") && !path10.isAbsolute(relative3);
 }
 async function resolveWorkingDirInsideProject(projectRoot, inputPath) {
-  const resolved = path9.resolve(projectRoot, inputPath);
+  const resolved = path10.resolve(projectRoot, inputPath);
   let stat3;
   try {
     stat3 = await fs8.stat(resolved);
@@ -5107,7 +5747,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}`);
@@ -5125,7 +5765,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();
@@ -5138,7 +5778,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) }
         });
       }
     },
@@ -5153,7 +5793,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);
@@ -5163,7 +5803,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)}`
             }
           });
@@ -5175,7 +5815,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,
@@ -5214,8 +5854,8 @@ function createProjectHandlers(ctx) {
           });
         } catch {
         }
-        const newSessionsDir = path10.join(
-          path10.dirname(ctx.globalConfigPath),
+        const newSessionsDir = path11.join(
+          path11.dirname(ctx.globalConfigPath),
           "projects",
           switchSlug,
           "sessions"
@@ -5254,7 +5894,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,
@@ -5266,8 +5906,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, {
@@ -5287,7 +5927,7 @@ function createProjectHandlers(ctx) {
           type: "projects.selected",
           payload: {
             root: selRoot,
-            name: selName || path10.basename(selRoot),
+            name: selName || path11.basename(selRoot),
             message: errMessage(err)
           }
         });
@@ -5318,7 +5958,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,
@@ -5660,7 +6300,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);
@@ -5675,7 +6315,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);
@@ -5982,10 +6622,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 = [];
@@ -6450,7 +7104,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) {
@@ -6459,7 +7113,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;
@@ -6486,7 +7140,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++;
@@ -6527,9 +7181,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;
               }
@@ -6587,7 +7241,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 {
@@ -6661,10 +7315,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) {
@@ -6796,12 +7450,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." };
@@ -6911,15 +7565,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);
@@ -6931,7 +7585,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;
@@ -6943,13 +7597,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) {
@@ -6960,21 +7614,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 });
@@ -7185,6 +7839,7 @@ 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);
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const mcpRegistry = new MCPRegistry({
     toolRegistry,
@@ -7228,7 +7883,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,
@@ -7248,7 +7903,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)
       });
@@ -7260,7 +7915,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()
@@ -7316,9 +7971,9 @@ async function startWebUI(opts = {}) {
   };
   const skillLoader = config.features.skills ? new DefaultSkillLoader2({ 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;
@@ -7422,6 +8077,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;
@@ -7479,7 +8136,9 @@ async function startWebUI(opts = {}) {
     "reasoningMode",
     "reasoningEffort",
     "reasoningPreserve",
-    "cacheTtl"
+    "cacheTtl",
+    "fallbackModels",
+    "fallbackAuto"
   ];
   const prefSnapshot = () => {
     const snapshot = {};
@@ -7510,6 +8169,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",
@@ -7790,6 +8451,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(
@@ -7829,7 +8513,7 @@ async function startWebUI(opts = {}) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path15.basename(projectRoot) || projectRoot,
+      projectName: path16.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: workingDir,
       mode: modeId,
@@ -7921,6 +8605,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);
@@ -8045,21 +8732,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);
@@ -8085,6 +8772,9 @@ async function startWebUI(opts = {}) {
   let mailboxRoutes;
   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;
@@ -8094,6 +8784,9 @@ async function startWebUI(opts = {}) {
     if (await handleMailboxRoute(ws, msg, mailboxRoutes)) 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 —
@@ -8390,6 +9083,10 @@ async function startWebUI(opts = {}) {
           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 });
@@ -8452,22 +9149,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) => {
@@ -8677,7 +9359,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);
@@ -8685,16 +9367,16 @@ 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);
     }
   };
   brainRoutes = {
@@ -8741,6 +9423,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,
@@ -8753,7 +9444,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,
@@ -8762,7 +9453,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}`);
@@ -8774,7 +9465,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}`
       },
@@ -8817,11 +9508,15 @@ async function startWebUI(opts = {}) {
 }
 export {
   AutoPhaseWebSocketHandler,
+  SddBoardWebSocketHandler,
+  SddWizardWebSocketHandler,
+  SpecsWebSocketHandler,
   WorktreeWebSocketHandler,
   addProvider,
   broadcast,
   browserOpenCommand,
   buildCspHeader,
+  buildSddWizardDeps,
   createCustomModeStore,
   createEternalSubscription,
   createHttpServer,