@wrongstack/webui-server 0.287.0 → 0.291.0

package/dist/index.js

@@ -1,9 +1,9 @@
-// src/server/autophase-ws-handler.ts
+// src/server/goal-ws-handler.ts
 import { spawnSync } from "node:child_process";
 import { toErrorMessage } from "@wrongstack/core/utils";
 import {
   assignNickname,
-  AutoPhasePlanner,
+  GoalPlanner,
   PhaseGraphBuilder,
   PhaseOrchestrator,
   PhaseStore,
@@ -11,10 +11,10 @@ import {
 } from "@wrongstack/core";
 function deriveTitle(goal) {
   const firstLine = goal.split("\n").map((l) => l.trim()).find(Boolean);
-  if (!firstLine) return "AutoPhase";
+  if (!firstLine) return "Goal";
   const sentence = firstLine.split(/(?<=[.!?])\s/)[0] ?? firstLine;
   const trimmed = sentence.length <= 64 ? sentence : `${sentence.slice(0, 63).trimEnd()}\u2026`;
-  return trimmed || "AutoPhase";
+  return trimmed || "Goal";
 }
 function isGitRepo(cwd) {
   try {
@@ -37,7 +37,7 @@ function commitsSince(cwd, baseSha, branch) {
     return [];
   }
 }
-var AutoPhaseWebSocketHandler = class {
+var GoalWebSocketHandler = class {
   constructor(agent, context, logger, storeDir, events, projectRoot, onBoardState) {
     this.agent = agent;
     this.context = context;
@@ -80,94 +80,94 @@ var AutoPhaseWebSocketHandler = class {
   }
   async handleMessage(msg) {
     switch (msg.type) {
-      case "autophase.start":
+      case "goal.start":
         await this.handleStart(msg.payload);
         break;
-      case "autophase.pause":
+      case "goal.pause":
         this.orchestrator?.pause();
-        this.broadcast({ type: "autophase.paused", payload: {} });
+        this.broadcast({ type: "goal.paused", payload: {} });
         break;
-      case "autophase.resume":
+      case "goal.resume":
         this.orchestrator?.resume();
-        this.broadcast({ type: "autophase.resumed", payload: {} });
+        this.broadcast({ type: "goal.resumed", payload: {} });
         break;
-      case "autophase.stop":
+      case "goal.stop":
         await this.handleStop();
         break;
-      case "autophase.clear":
+      case "goal.clear":
         await this.handleClear();
         break;
-      case "autophase.revert":
+      case "goal.revert":
         await this.handleRevert();
         break;
-      case "autophase.status":
+      case "goal.status":
         this.broadcastState();
         break;
-      case "autophase.selectPhase": {
+      case "goal.selectPhase": {
         const phaseId = msg.payload?.phaseId;
         if (phaseId && this.graph) {
           this.broadcastState(phaseId);
         }
         break;
       }
-      case "autophase.taskStatus": {
+      case "goal.taskStatus": {
         const { taskId, status } = msg.payload;
         await this.handleTaskStatusChange(taskId, status);
         break;
       }
-      case "autophase.moveTask": {
+      case "goal.moveTask": {
         const { taskId, toPhaseId } = msg.payload;
         if (this.orchestrator?.moveTask(taskId, toPhaseId)) this.afterBoardMutation();
         break;
       }
-      case "autophase.assignTask": {
+      case "goal.assignTask": {
         const { taskId, agentId, agentName } = msg.payload;
         if (this.orchestrator?.setTaskAssignee(taskId, agentId, agentName)) this.afterBoardMutation();
         break;
       }
-      case "autophase.addTask": {
+      case "goal.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": {
+      case "goal.retryTask":
+      case "goal.runTask": {
         const { taskId } = msg.payload;
         if (this.orchestrator?.requeueTask(taskId)) this.afterBoardMutation();
         break;
       }
-      case "autophase.toggleAutonomous": {
+      case "goal.toggleAutonomous": {
         const autonomous = msg.payload?.autonomous ?? !this.graph?.autonomous;
         if (this.graph) {
           this.graph.autonomous = autonomous;
           await this.store.save(this.graph);
-          this.broadcast({ type: "autophase.state", payload: this.buildState() });
+          this.broadcast({ type: "goal.state", payload: this.buildState() });
         }
         break;
       }
-      case "autophase.save": {
+      case "goal.save": {
         if (this.graph) {
           await this.store.save(this.graph);
-          this.broadcast({ type: "autophase.saved", payload: { graphId: this.graph.id } });
+          this.broadcast({ type: "goal.saved", payload: { graphId: this.graph.id } });
         }
         break;
       }
-      case "autophase.list": {
+      case "goal.list": {
         const graphs = await this.store.list();
-        this.broadcast({ type: "autophase.list", payload: { graphs } });
+        this.broadcast({ type: "goal.list", payload: { graphs } });
         break;
       }
-      case "autophase.load": {
+      case "goal.load": {
         const graphId = msg.payload?.graphId;
         if (graphId) {
           const graph = await this.store.load(graphId);
           if (graph) {
             this.graph = graph;
-            this.broadcast({ type: "autophase.state", payload: this.buildState() });
+            this.broadcast({ type: "goal.state", payload: this.buildState() });
           } else {
-            this.broadcast({ type: "autophase.error", payload: { message: `Graph not found: ${graphId}` } });
+            this.broadcast({ type: "goal.error", payload: { message: `Graph not found: ${graphId}` } });
           }
         }
         break;
@@ -182,14 +182,14 @@ var AutoPhaseWebSocketHandler = class {
     this.stopping = false;
     const phases = Array.isArray(payload?.phases) ? payload.phases : await this.planPhases(goal, this.abort.signal);
     if (this.stopping || this.abort.signal.aborted) {
-      this.broadcast({ type: "autophase.stopped", payload: { title } });
+      this.broadcast({ type: "goal.stopped", payload: { title } });
       return;
     }
-    this.logger.info(`[AutoPhase] Starting: ${title}`);
+    this.logger.info(`[Goal] Starting: ${title}`);
     const graph = await new PhaseGraphBuilder({ title, description: goal, phases, autonomous }).build();
     this.graph = graph;
     await this.store.save(graph);
-    const useWorktrees = payload?.worktrees ?? process.env["WRONGSTACK_AUTOPHASE_WORKTREES"] !== "0";
+    const useWorktrees = payload?.worktrees ?? process.env["WRONGSTACK_GOAL_WORKTREES"] !== "0";
     if (!this.worktrees && this.events && this.projectRoot && useWorktrees && isGitRepo(this.projectRoot)) {
       this.worktrees = new WorktreeManager({
         projectRoot: this.projectRoot,
@@ -204,18 +204,18 @@ var AutoPhaseWebSocketHandler = class {
       graph,
       ctx: {
         executeTask: async (task, phaseId, env) => {
-          this.logger.info(`[AutoPhase] [${phaseId}] Executing: ${task.title}`);
+          this.logger.info(`[Goal] [${phaseId}] Executing: ${task.title}`);
           const result = await this.executeTaskWithAgent(task, phaseId, env);
-          this.logger.info(`[AutoPhase] [${phaseId}] Completed: ${task.title}`);
+          this.logger.info(`[Goal] [${phaseId}] Completed: ${task.title}`);
           return result;
         },
         onPhaseComplete: (phase) => {
-          this.logger.info(`[AutoPhase] Phase completed: ${phase.name}`);
+          this.logger.info(`[Goal] Phase completed: ${phase.name}`);
           void this.store.save(graph);
           this.broadcastState();
         },
         onPhaseFail: (phase, error) => {
-          this.logger.error(`[AutoPhase] Phase failed: ${phase.name} \u2014 ${error.message}`);
+          this.logger.error(`[Goal] Phase failed: ${phase.name} \u2014 ${error.message}`);
           void this.store.save(graph);
           this.broadcastState();
         }
@@ -237,20 +237,20 @@ var AutoPhaseWebSocketHandler = class {
       this.stopBroadcast();
       const failed = graph.failedPhaseIds.length > 0;
       this.broadcast(
-        failed ? { type: "autophase.failed", payload: { title } } : { type: "autophase.completed", payload: { title } }
+        failed ? { type: "goal.failed", payload: { title } } : { type: "goal.completed", payload: { title } }
       );
       this.broadcastState();
     }).catch((err) => {
-      this.logger.error(`[AutoPhase] Aborted: ${toErrorMessage(err)}`);
+      this.logger.error(`[Goal] Aborted: ${toErrorMessage(err)}`);
       this.stopBroadcast();
-      this.broadcast({ type: "autophase.failed", payload: { title, error: String(err) } });
+      this.broadcast({ type: "goal.failed", payload: { title, error: String(err) } });
     });
   }
   /**
    * Halt the run NOW — at any phase. Sets `stopping` (so a planning turn that
    * resolves afterwards bails), aborts in-flight agents, stops the orchestrator
    * tick, and ends the live broadcast. The board is kept for review; use
-   * `autophase.clear` to reset or `autophase.revert` to undo the changes.
+   * `goal.clear` to reset or `goal.revert` to undo the changes.
    */
   async handleStop() {
     this.stopping = true;
@@ -258,12 +258,12 @@ var AutoPhaseWebSocketHandler = class {
     this.orchestrator?.stop();
     this.stopBroadcast();
     if (this.graph) await this.store.save(this.graph).catch(() => void 0);
-    this.broadcast({ type: "autophase.stopped", payload: { title: this.graph?.title } });
+    this.broadcast({ type: "goal.stopped", payload: { title: this.graph?.title } });
   }
   /**
    * Stop + wipe: tear down phase worktrees and reset to an empty board so the UI
    * returns to the start screen ("new one"). Does NOT touch already-merged commits
-   * on the base branch — that is `autophase.revert`.
+   * on the base branch — that is `goal.revert`.
    */
   async handleClear() {
     await this.handleStop();
@@ -272,8 +272,8 @@ var AutoPhaseWebSocketHandler = class {
     this.graph = null;
     this.runBase = null;
     this.usedNicknames.clear();
-    this.broadcast({ type: "autophase.cleared", payload: {} });
-    this.broadcast({ type: "autophase.state", payload: this.buildState() });
+    this.broadcast({ type: "goal.cleared", payload: {} });
+    this.broadcast({ type: "goal.state", payload: this.buildState() });
   }
   /**
    * Stop + undo: remove phase worktrees, then history-preservingly `git revert`
@@ -285,7 +285,7 @@ var AutoPhaseWebSocketHandler = class {
     await this.handleStop();
     if (!this.worktrees || !this.runBase || !this.projectRoot) {
       this.broadcast({
-        type: "autophase.reverted",
+        type: "goal.reverted",
         payload: { ok: false, reverted: 0, reason: "no git baseline was captured for this run" }
       });
       return;
@@ -293,13 +293,13 @@ var AutoPhaseWebSocketHandler = class {
     await this.worktrees.cleanupAllManaged().catch(() => void 0);
     const shas = commitsSince(this.projectRoot, this.runBase.sha, this.runBase.branch);
     const res = await this.worktrees.revertCommits(this.runBase.branch, shas);
-    this.broadcast({ type: "autophase.reverted", payload: res });
+    this.broadcast({ type: "goal.reverted", payload: res });
     if (res.ok) {
       this.orchestrator = null;
       this.graph = null;
       this.runBase = null;
-      this.broadcast({ type: "autophase.cleared", payload: {} });
-      this.broadcast({ type: "autophase.state", payload: this.buildState() });
+      this.broadcast({ type: "goal.cleared", payload: {} });
+      this.broadcast({ type: "goal.state", payload: this.buildState() });
     }
   }
   /** Generic fallback phases when the LLM planner produces nothing usable. */
@@ -318,7 +318,7 @@ var AutoPhaseWebSocketHandler = class {
    *  uninterruptible). */
   async planPhases(goal, signal) {
     try {
-      const planner = new AutoPhasePlanner({
+      const planner = new GoalPlanner({
         goal,
         runOnce: async (prompt) => {
           const result = await this.agent.run(prompt, {
@@ -330,12 +330,12 @@ var AutoPhaseWebSocketHandler = class {
       const { phases, parseFailed } = await planner.plan();
       if (!parseFailed && phases.length > 0) {
         const todos = phases.reduce((n, p) => n + (p.taskTemplates?.length ?? 0), 0);
-        this.logger.info(`[AutoPhase] Planned ${phases.length} phases / ${todos} todos for: ${goal}`);
+        this.logger.info(`[Goal] Planned ${phases.length} phases / ${todos} todos for: ${goal}`);
         return phases;
       }
-      this.logger.info(`[AutoPhase] Planner produced no phases; using defaults for: ${goal}`);
+      this.logger.info(`[Goal] Planner produced no phases; using defaults for: ${goal}`);
     } catch (err) {
-      this.logger.error(`[AutoPhase] Planning failed, using defaults: ${toErrorMessage(err)}`);
+      this.logger.error(`[Goal] Planning failed, using defaults: ${toErrorMessage(err)}`);
     }
     return this.defaultPhases();
   }
@@ -383,7 +383,7 @@ Type: ${task.type}`;
     if (this.broadcastInterval) return;
     this.broadcastInterval = setInterval(() => {
       const progress = this.orchestrator?.getProgress();
-      if (progress) this.broadcast({ type: "autophase.progress", payload: progress });
+      if (progress) this.broadcast({ type: "goal.progress", payload: progress });
       this.broadcastState();
     }, 2e3);
   }
@@ -396,13 +396,13 @@ Type: ${task.type}`;
   broadcastState(activePhaseId) {
     if (!this.graph) return;
     const state = this.buildState(activePhaseId);
-    this.broadcast({ type: "autophase.state", payload: state });
+    this.broadcast({ type: "goal.state", payload: state });
     if (this.onBoardState) {
       try {
         this.onBoardState(this.graph.id, state);
       } catch (err) {
         this.logger.error(
-          `[AutoPhase] board-state tap failed: ${err instanceof Error ? err.message : String(err)}`
+          `[Goal] board-state tap failed: ${err instanceof Error ? err.message : String(err)}`
         );
       }
     }
@@ -478,7 +478,7 @@ Type: ${task.type}`;
       autonomous: this.graph.autonomous,
       totalTasks,
       completedTasks,
-      // Structured progress + lastError consumed by the autophase store (were
+      // Structured progress + lastError consumed by the goal store (were
       // defined client-side but never sent, so they stayed null on the board).
       progress: {
         totalPhases: phases.length,
@@ -494,7 +494,7 @@ Type: ${task.type}`;
   sendState(client) {
     if (!this.graph) return;
     const state = this.buildState();
-    this.send(client, { type: "autophase.state", payload: state });
+    this.send(client, { type: "goal.state", payload: state });
   }
   broadcast(msg) {
     const data = JSON.stringify(msg);
@@ -1752,9 +1752,9 @@ async function handleGitInfo(ws, projectRoot) {
   const cwd = projectRoot || void 0;
   try {
     const { execFile: ef } = await import("node:child_process");
-    const git = (args) => new Promise((resolve10) => {
+    const git = (args) => new Promise((resolve12) => {
       ef("git", args, { cwd, timeout: 3e3 }, (err, stdout) => {
-        resolve10(err ? "" : stdout.trim());
+        resolve12(err ? "" : stdout.trim());
       });
     });
     const [branchRaw, diffRaw, statusRaw, upstreamRaw] = await Promise.all([
@@ -1780,12 +1780,12 @@ async function handleGitInfo(ws, projectRoot) {
 function makeGit(cwd) {
   return async (args) => {
     const { execFile: ef } = await import("node:child_process");
-    return new Promise((resolve10) => {
+    return new Promise((resolve12) => {
       ef(
         "git",
         args,
         { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 * 16 },
-        (err, stdout) => resolve10(err ? "" : stdout)
+        (err, stdout) => resolve12(err ? "" : stdout)
       );
     });
   };
@@ -1809,15 +1809,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 path23 = m[3] ?? "";
-        if (path23 === "") {
+        let path24 = m[3] ?? "";
+        if (path24 === "") {
           i += 1;
-          path23 = parts[i + 1] ?? parts[i] ?? "";
+          path24 = parts[i + 1] ?? parts[i] ?? "";
           i += 1;
         }
-        if (!path23) continue;
-        const prev = counts.get(path23) ?? { added: 0, deleted: 0 };
-        counts.set(path23, { added: prev.added + added, deleted: prev.deleted + deleted });
+        if (!path24) continue;
+        const prev = counts.get(path24) ?? { added: 0, deleted: 0 };
+        counts.set(path24, { added: prev.added + added, deleted: prev.deleted + deleted });
       }
     };
     parseNumstat(unstagedNumstat);
@@ -1829,7 +1829,7 @@ async function handleGitChanges(ws, projectRoot) {
       if (!rec || rec.length < 3) continue;
       const x = rec[0] ?? " ";
       const y = rec[1] ?? " ";
-      const path23 = rec.slice(3);
+      const path24 = rec.slice(3);
       const isRename = x === "R" || x === "C" || y === "R" || y === "C";
       if (isRename) i += 1;
       let status;
@@ -1841,13 +1841,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(path23)?.added ?? 0;
-      let deleted = counts.get(path23)?.deleted ?? 0;
+      let added = counts.get(path24)?.added ?? 0;
+      let deleted = counts.get(path24)?.deleted ?? 0;
       if (status === "?") {
         added = 0;
         deleted = 0;
       }
-      files.push({ path: path23, status, added, deleted, staged });
+      files.push({ path: path24, status, added, deleted, staged });
     }
     send(ws, { type: "git.changes", payload: { files } });
   } catch (err) {
@@ -1858,10 +1858,10 @@ async function handleGitChanges(ws, projectRoot) {
   }
 }
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
-async function handleGitDiff(ws, projectRoot, path23) {
+async function handleGitDiff(ws, projectRoot, path24) {
   const cwd = projectRoot || void 0;
-  const reply = (extra) => send(ws, { type: "git.diff", payload: { path: path23, ...extra } });
-  if (!path23 || path23.includes("\0") || path23.includes("..") || nodePath.isAbsolute(path23)) {
+  const reply = (extra) => send(ws, { type: "git.diff", payload: { path: path24, ...extra } });
+  if (!path24 || path24.includes("\0") || path24.includes("..") || nodePath.isAbsolute(path24)) {
     reply({ oldText: "", newText: "", error: "invalid path" });
     return;
   }
@@ -1869,10 +1869,10 @@ async function handleGitDiff(ws, projectRoot, path23) {
     const git = makeGit(cwd);
     const { readFile: readFile11 } = await import("node:fs/promises");
     const { join: join15 } = await import("node:path");
-    const oldText = await git(["show", `HEAD:${path23}`]);
+    const oldText = await git(["show", `HEAD:${path24}`]);
     let newText = "";
     try {
-      const abs = cwd ? join15(cwd, path23) : path23;
+      const abs = cwd ? join15(cwd, path24) : path24;
       const buf = await readFile11(abs);
       if (buf.includes(0)) {
         reply({ oldText: "", newText: "", binary: true });
@@ -1901,9 +1901,10 @@ async function handleGitDiff(ws, projectRoot, path23) {
 }
 
 // src/server/http-server.ts
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as http from "node:http";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
+import * as v8 from "node:v8";
 
 // src/server/http-server/api-handlers.ts
 async function handleApiSessions(res, globalRoot) {
@@ -2091,7 +2092,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
     return;
   }
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths3, DefaultSessionStore: DefaultSessionStore2, DefaultSessionReader: DefaultSessionReader2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths4, DefaultSessionStore: DefaultSessionStore2, DefaultSessionReader: DefaultSessionReader2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -2099,7 +2100,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths3({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths4({ projectRoot: entry.projectRoot, globalRoot });
     const store = new DefaultSessionStore2({ dir: paths.projectSessions });
     const reader = new DefaultSessionReader2({ store });
     const rawEntries = [];
@@ -2126,7 +2127,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
   }
 }
 function readJsonBody(req) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve12, reject) => {
     let data = "";
     req.on("data", (chunk) => {
       data += chunk;
@@ -2137,7 +2138,7 @@ function readJsonBody(req) {
     });
     req.on("end", () => {
       try {
-        resolve10(data ? JSON.parse(data) : {});
+        resolve12(data ? JSON.parse(data) : {});
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -2173,7 +2174,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
   const priority = ["low", "normal", "high"].includes(rawPriority) ? rawPriority : "high";
   const subject = typeof body["subject"] === "string" && body["subject"].trim() ? body["subject"].trim() : "Message from Fleet HQ";
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths3, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths4, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -2181,7 +2182,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths3({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths4({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = new GlobalMailbox4(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.send({ from, to, type, subject, body: text, priority });
@@ -2199,7 +2200,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
     return;
   }
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths3, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths4, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -2207,7 +2208,7 @@ async function handleApiSessionMailbox(res, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths3({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths4({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = new GlobalMailbox4(paths.projectDir);
     const leaderAddr = `leader@${mailboxSessionTag2(sessionId)}`;
     const [inbound, outbound] = await Promise.all([
@@ -2257,7 +2258,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
   const reason = typeof body["reason"] === "string" && body["reason"].trim() ? body["reason"].trim() : "Operator requested stop from Fleet HQ";
   const from = typeof body["from"] === "string" && body["from"].trim() ? body["from"].trim() : "human@webui";
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths3, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths4, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const entry = await registry.get(sessionId);
     if (!entry) {
@@ -2265,7 +2266,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
       res.end(JSON.stringify({ error: "Session not found" }));
       return;
     }
-    const paths = resolveWstackPaths3({ projectRoot: entry.projectRoot, globalRoot });
+    const paths = resolveWstackPaths4({ projectRoot: entry.projectRoot, globalRoot });
     const mailbox = new GlobalMailbox4(paths.projectDir);
     const to = `leader@${mailboxSessionTag2(sessionId)}`;
     const sent = await mailbox.send({
@@ -2305,7 +2306,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
   }
   const from = typeof body["from"] === "string" && body["from"].trim() ? body["from"].trim() : "human@webui";
   try {
-    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths3, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
+    const { SessionRegistry, resolveWstackPaths: resolveWstackPaths4, GlobalMailbox: GlobalMailbox4, mailboxSessionTag: mailboxSessionTag2 } = await import("@wrongstack/core");
     const registry = new SessionRegistry(globalRoot);
     const all = await registry.list();
     const mySlug = all.find((s) => s.pid === process.pid)?.projectSlug;
@@ -2317,7 +2318,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
     }
     const mbByDir = /* @__PURE__ */ new Map();
     const mailboxFor = (projectRoot) => {
-      const dir = resolveWstackPaths3({ projectRoot, globalRoot }).projectDir;
+      const dir = resolveWstackPaths4({ projectRoot, globalRoot }).projectDir;
       let mb = mbByDir.get(dir);
       if (!mb) {
         mb = new GlobalMailbox4(dir);
@@ -2380,14 +2381,14 @@ function pushEvent(event) {
   }
 }
 function parseBody(req) {
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve12, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString("utf-8");
     });
     req.on("end", () => {
       try {
-        resolve10(JSON.parse(body));
+        resolve12(JSON.parse(body));
       } catch {
         reject(new Error("Invalid JSON"));
       }
@@ -2462,6 +2463,251 @@ function getAnalyticsBuffer() {
   return [...EVENT_BUFFER];
 }
 
+// src/server/codemap-handlers.ts
+import { packageGraphService, fileGraphService, symbolGraphService } from "@wrongstack/tools";
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function handleCodemapPackages(res, deps2) {
+  try {
+    const graph = packageGraphService({
+      projectRoot: deps2.projectRoot,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    });
+    sendJson(res, 200, graph);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sendJson(res, 503, { error: "CodeMap index unavailable", detail: msg });
+  }
+}
+function handleCodemapFiles(res, deps2, pkg) {
+  if (!pkg) {
+    sendJson(res, 400, { error: 'Missing "package" query parameter' });
+    return;
+  }
+  try {
+    const graph = fileGraphService({
+      projectRoot: deps2.projectRoot,
+      packageFilter: pkg,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    });
+    sendJson(res, 200, graph);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sendJson(res, 503, { error: "CodeMap index unavailable", detail: msg });
+  }
+}
+function handleCodemapSymbols(res, deps2, file) {
+  if (!file) {
+    sendJson(res, 400, { error: 'Missing "file" query parameter' });
+    return;
+  }
+  try {
+    const graph = symbolGraphService({
+      projectRoot: deps2.projectRoot,
+      fileFilter: file,
+      ...deps2.indexDir ? { indexDir: deps2.indexDir } : {}
+    });
+    sendJson(res, 200, graph);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    sendJson(res, 503, { error: "CodeMap index unavailable", detail: msg });
+  }
+}
+
+// src/server/techstack-handlers.ts
+import { randomUUID } from "node:crypto";
+var DEEP_DIVE_TIMEOUT_MS = 6e4;
+function sendJson2(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+async function buildResearcher(deps2, kind) {
+  if (kind !== "analyze" || !deps2.getLlm) return void 0;
+  const { createProviderLlm, createResearcher, createToolSearch } = await import("@wrongstack/techstack");
+  const llm = createProviderLlm(deps2.getLlm);
+  if (!llm) return void 0;
+  return createResearcher({ llm, search: createToolSearch() });
+}
+function handleTechStackSnapshot(res, deps2) {
+  try {
+    const snapshot = deps2.store.getSnapshot(deps2.projectId);
+    if (!snapshot) {
+      sendJson2(res, 404, { snapshot: null, stale: false });
+      return;
+    }
+    const ageMs = Date.now() - new Date(snapshot.createdAt).getTime();
+    sendJson2(res, 200, { snapshot, stale: ageMs > 24 * 60 * 60 * 1e3 });
+  } catch (error) {
+    sendJson2(res, 500, {
+      error: "TechStack store unavailable",
+      detail: errorMessage(error)
+    });
+  }
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function requireJobDeps(res, deps2) {
+  if (!deps2.projectRoot || !deps2.engine) {
+    sendJson2(res, 503, { error: "TechStack engine unavailable" });
+    return false;
+  }
+  return true;
+}
+function startJob(res, deps2, kind) {
+  if (!requireJobDeps(res, deps2)) return;
+  const jobId = randomUUID();
+  const controller = new AbortController();
+  deps2.runningJobs?.set(jobId, controller);
+  deps2.emit?.({ type: "techstack.job.started", payload: { jobId, kind } });
+  sendJson2(res, 202, { jobId, kind, status: "queued" });
+  void buildResearcher(deps2, kind).catch(() => void 0).then(
+    (researcher) => deps2.engine.analyze(deps2.projectId, {
+      targetRoot: deps2.projectRoot,
+      requestedBy: "webui",
+      online: kind === "analyze",
+      jobId,
+      signal: controller.signal,
+      researcher,
+      onProgress: (phase, completed, total) => {
+        deps2.emit?.({
+          type: "techstack.job.progress",
+          payload: { jobId, phase, completed, total }
+        });
+      }
+    })
+  ).then(({ snapshot }) => {
+    if (controller.signal.aborted) return;
+    deps2.emit?.({
+      type: "techstack.snapshot.updated",
+      payload: { snapshot, stale: false }
+    });
+  }).catch((error) => {
+    if (controller.signal.aborted) {
+      deps2.emit?.({ type: "techstack.job.cancelled", payload: { jobId } });
+      return;
+    }
+    deps2.emit?.({
+      type: "techstack.job.failed",
+      payload: { jobId, error: errorMessage(error) }
+    });
+  }).finally(() => {
+    deps2.runningJobs?.delete(jobId);
+  });
+}
+function handleTechStackInventory(res, deps2) {
+  startJob(res, deps2, "inventory");
+}
+function handleTechStackAnalyze(res, deps2) {
+  startJob(res, deps2, "analyze");
+}
+function handleTechStackCancel(res, deps2, jobId) {
+  const controller = deps2.runningJobs?.get(jobId);
+  if (controller && !controller.signal.aborted) controller.abort();
+  deps2.store.updateJobStatus(jobId, "cancelled");
+  deps2.emit?.({ type: "techstack.job.cancelled", payload: { jobId } });
+  sendJson2(res, 200, { jobId, status: "cancelled" });
+}
+async function handleTechStackDependencyResearch(res, deps2, dependencyId) {
+  const snapshot = deps2.store.getSnapshot(deps2.projectId);
+  const dependency = snapshot?.dependencies.find((dep) => dep.id === dependencyId);
+  if (!dependency) {
+    sendJson2(res, 404, { error: "Dependency not found in the current snapshot" });
+    return;
+  }
+  let researcher;
+  try {
+    researcher = await buildResearcher(deps2, "analyze");
+  } catch (error) {
+    sendJson2(res, 503, { error: "Research unavailable", detail: errorMessage(error) });
+    return;
+  }
+  if (!researcher) {
+    sendJson2(res, 503, {
+      error: "No model configured \u2014 connect a provider to run LLM analysis."
+    });
+    return;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort(new Error("research timeout"));
+  }, DEEP_DIVE_TIMEOUT_MS);
+  timeout.unref?.();
+  try {
+    const { triageCandidates } = await import("@wrongstack/techstack");
+    const [triaged] = triageCandidates([dependency], { limit: 1 });
+    const findings = await researcher.research(
+      [triaged ?? { dependency, cluster: "breaking_change", priority: 0 }],
+      { signal: controller.signal }
+    );
+    sendJson2(res, 200, { dependencyId, findings });
+  } catch (error) {
+    sendJson2(res, 500, { error: "Research failed", detail: errorMessage(error) });
+  } finally {
+    clearTimeout(timeout);
+    controller.abort();
+  }
+}
+function handleTechStackJobStatus(res, deps2, jobId) {
+  const job = deps2.store.getJob(jobId);
+  if (!job) {
+    sendJson2(res, 404, { error: "Job not found" });
+    return;
+  }
+  sendJson2(res, 200, { job });
+}
+function handleTechStackReport(res, deps2, reportId, format) {
+  const snapshot = deps2.store.getSnapshotById(reportId);
+  if (!snapshot) {
+    sendJson2(res, 404, { error: "Report not found" });
+    return;
+  }
+  if (deps2.engine) {
+    const report = deps2.engine.generateReport(snapshot, format);
+    res.writeHead(200, {
+      "Content-Type": format === "json" ? "application/json" : "text/markdown",
+      "Content-Disposition": `attachment; filename="techstack-report.${format}"`
+    });
+    res.end(report);
+  } else {
+    sendJson2(res, 200, snapshot);
+  }
+}
+
+// src/server/projects-manifest.ts
+import * as fs5 from "node:fs/promises";
+import * as path6 from "node:path";
+import { projectSlug } from "@wrongstack/core";
+function projectsJsonPath(globalConfigPath) {
+  const base = path6.dirname(globalConfigPath);
+  return path6.join(base, "projects.json");
+}
+async function loadManifest(globalConfigPath) {
+  try {
+    const raw = await fs5.readFile(projectsJsonPath(globalConfigPath), "utf8");
+    const parsed = JSON.parse(raw);
+    return { projects: parsed.projects ?? [] };
+  } catch {
+    return { projects: [] };
+  }
+}
+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");
+}
+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 });
+  return dir;
+}
+
 // src/server/ws-auth.ts
 import { Buffer as Buffer2 } from "node:buffer";
 import { timingSafeEqual } from "node:crypto";
@@ -2647,9 +2893,9 @@ function buildCspHeader(wsPort, requestHost, publicWsUrl) {
   return `default-src 'self'; script-src ${scriptSrc}; style-src 'self' 'unsafe-inline'; connect-src ${Array.from(connect).join(" ")}; img-src 'self' data:; font-src 'self' data:; worker-src 'self' blob:; object-src 'none'; base-uri 'self'; frame-ancestors 'none'; form-action 'self'`;
 }
 function isInsideDist(candidate, distDir) {
-  const root = path6.resolve(distDir);
-  const resolved = path6.resolve(candidate);
-  return resolved === root || resolved.startsWith(root + path6.sep);
+  const root = path7.resolve(distDir);
+  const resolved = path7.resolve(candidate);
+  return resolved === root || resolved.startsWith(root + path7.sep);
 }
 function decodeSessionId(segment) {
   try {
@@ -2660,10 +2906,19 @@ function decodeSessionId(segment) {
 }
 function createHttpServer(opts) {
   const port = opts.port ?? Number.parseInt(process.env["PORT"] ?? "3456", 10);
-  const distDir = path6.resolve(opts.distDir);
+  const distDir = path7.resolve(opts.distDir);
   const wsPort = opts.wsPort;
   const requireAccessToken = Boolean(opts.requireToken) || !isLoopbackBind(opts.host);
-  return http.createServer(async (req, res) => {
+  let techStackRuntime = null;
+  const getTechStackRuntime = async () => {
+    if (!opts.projectRoot) throw new Error("Project root not configured");
+    techStackRuntime ??= import("@wrongstack/techstack").then(({ TechStackEngine, TechStackStore }) => {
+      const store = new TechStackStore({ projectSlug: generateProjectSlug(opts.projectRoot) });
+      return { store, engine: new TechStackEngine(store), runningJobs: /* @__PURE__ */ new Map() };
+    });
+    return techStackRuntime;
+  };
+  const server = http.createServer(async (req, res) => {
     try {
       const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
       const providedAccessToken = requestToken(req, url);
@@ -2814,6 +3069,127 @@ function createHttpServer(opts) {
         await handleApiAnalyticsSummary(res);
         return;
       }
+      if (url.pathname === "/api/codemap/packages" && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        if (!opts.projectRoot) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Project root not configured" }));
+          return;
+        }
+        handleCodemapPackages(res, {
+          projectRoot: opts.projectRoot,
+          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
+        });
+        return;
+      }
+      if (url.pathname === "/api/codemap/files" && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        if (!opts.projectRoot) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Project root not configured" }));
+          return;
+        }
+        const pkg = url.searchParams.get("package") ?? "";
+        handleCodemapFiles(res, {
+          projectRoot: opts.projectRoot,
+          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
+        }, pkg);
+        return;
+      }
+      if (url.pathname === "/api/codemap/symbols" && req.method === "GET") {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        if (!opts.projectRoot) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Project root not configured" }));
+          return;
+        }
+        const file = url.searchParams.get("file") ?? "";
+        handleCodemapSymbols(res, {
+          projectRoot: opts.projectRoot,
+          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
+        }, file);
+        return;
+      }
+      if (url.pathname.startsWith("/api/techstack/")) {
+        if (requireAccessToken && !accessTokenOk) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Unauthorized" }));
+          return;
+        }
+        if (!opts.projectRoot) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Project root not configured" }));
+          return;
+        }
+        try {
+          const runtime = await getTechStackRuntime();
+          const deps2 = {
+            projectId: opts.projectRoot,
+            projectRoot: opts.projectRoot,
+            store: runtime.store,
+            engine: runtime.engine,
+            runningJobs: runtime.runningJobs,
+            emit: opts.onTechStackEvent,
+            getLlm: opts.getLlm
+          };
+          if (url.pathname === "/api/techstack/snapshot" && req.method === "GET") {
+            handleTechStackSnapshot(res, deps2);
+            return;
+          }
+          if (url.pathname === "/api/techstack/inventory" && req.method === "POST") {
+            handleTechStackInventory(res, deps2);
+            return;
+          }
+          if (url.pathname === "/api/techstack/analyze" && req.method === "POST") {
+            handleTechStackAnalyze(res, deps2);
+            return;
+          }
+          const cancelMatch = /^\/api\/techstack\/jobs\/([^/]+)\/cancel$/.exec(url.pathname);
+          if (cancelMatch && req.method === "POST") {
+            handleTechStackCancel(res, deps2, decodeURIComponent(cancelMatch[1]));
+            return;
+          }
+          const jobMatch = /^\/api\/techstack\/jobs\/([^/]+)$/.exec(url.pathname);
+          if (jobMatch && req.method === "GET") {
+            handleTechStackJobStatus(res, deps2, decodeURIComponent(jobMatch[1]));
+            return;
+          }
+          const reportMatch = /^\/api\/techstack\/reports\/([^/]+)$/.exec(url.pathname);
+          if (reportMatch && req.method === "GET") {
+            const fmt = url.searchParams.get("format") === "json" ? "json" : "md";
+            handleTechStackReport(res, deps2, decodeURIComponent(reportMatch[1]), fmt);
+            return;
+          }
+          const researchMatch = /^\/api\/techstack\/deps\/([^/]+)\/research$/.exec(url.pathname);
+          if (researchMatch && req.method === "POST") {
+            await handleTechStackDependencyResearch(
+              res,
+              deps2,
+              decodeURIComponent(researchMatch[1])
+            );
+            return;
+          }
+        } catch (error) {
+          res.writeHead(503, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "TechStack store unavailable",
+            detail: error instanceof Error ? error.message : String(error)
+          }));
+          return;
+        }
+      }
       if (url.pathname === "/debug/watcher-metrics" && req.method === "GET") {
         if (requireAccessToken && !accessTokenOk) {
           res.writeHead(401, { "Content-Type": "application/json" });
@@ -2835,23 +3211,40 @@ function createHttpServer(opts) {
         }
         return;
       }
+      if (url.pathname === "/debug/system" && req.method === "GET") {
+        res.writeHead(200, {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store"
+        });
+        res.end(
+          JSON.stringify({
+            pid: process.pid,
+            memoryUsage: process.memoryUsage(),
+            heapLimit: v8.getHeapStatistics().heap_size_limit,
+            uptime: process.uptime(),
+            cpuUsage: process.cpuUsage(),
+            timestamp: Date.now()
+          })
+        );
+        return;
+      }
       let filePath;
       if (url.pathname === "/" || url.pathname === "") {
-        filePath = path6.join(distDir, "index.html");
+        filePath = path7.join(distDir, "index.html");
       } else if (url.pathname.startsWith("/assets/")) {
-        filePath = path6.join(distDir, url.pathname);
+        filePath = path7.join(distDir, url.pathname);
       } else if (url.pathname.startsWith("/")) {
-        filePath = path6.join(distDir, url.pathname);
+        filePath = path7.join(distDir, url.pathname);
       } else {
-        filePath = path6.join(distDir, "index.html");
+        filePath = path7.join(distDir, "index.html");
       }
-      const resolvedPath = path6.resolve(filePath);
+      const resolvedPath = path7.resolve(filePath);
       if (!isInsideDist(resolvedPath, distDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext = path6.extname(resolvedPath);
+      const ext = path7.extname(resolvedPath);
       const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
       res.setHeader("Content-Type", contentType);
       res.setHeader("X-Content-Type-Options", "nosniff");
@@ -2863,18 +3256,18 @@ function createHttpServer(opts) {
           "Content-Security-Policy",
           buildCspHeader(wsPort, requestHostForCsp(req.headers.host), opts.publicWsUrl)
         );
-        const html = await fs5.readFile(resolvedPath, "utf8");
+        const html = await fs6.readFile(resolvedPath, "utf8");
         res.writeHead(200);
         res.end(injectWsConfig(html, { wsPort, publicWsUrl: opts.publicWsUrl }));
         return;
       }
-      const fileContent = await fs5.readFile(resolvedPath);
+      const fileContent = await fs6.readFile(resolvedPath);
       res.writeHead(200);
       res.end(fileContent);
     } catch (err) {
       if (err.code === "ENOENT") {
         try {
-          const html = await fs5.readFile(path6.join(distDir, "index.html"), "utf8");
+          const html = await fs6.readFile(path7.join(distDir, "index.html"), "utf8");
           res.writeHead(200, {
             "Content-Type": "text/html",
             "X-Content-Type-Options": "nosniff",
@@ -2897,18 +3290,26 @@ function createHttpServer(opts) {
       }
     }
   });
+  server.once("close", () => {
+    void techStackRuntime?.then(({ store, runningJobs }) => {
+      for (const controller of runningJobs.values()) controller.abort();
+      runningJobs.clear();
+      store.close();
+    }).catch(() => void 0);
+  });
+  return server;
 }
 
 // src/server/instance-registry.ts
 import * as os from "node:os";
-import * as path7 from "node:path";
-import * as fs6 from "node:fs/promises";
+import * as path8 from "node:path";
+import * as fs7 from "node: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;
@@ -2921,7 +3322,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;
@@ -3214,7 +3615,7 @@ async function handleMcpResources(ws, msg, _globalConfigPath, mcpRegistry) {
       payload: { name: serverName, resources, resourceTemplates }
     });
   } catch (err) {
-    sendContentError(ws, "resources", serverName, errorMessage(err));
+    sendContentError(ws, "resources", serverName, errorMessage2(err));
   }
 }
 async function handleMcpPrompts(ws, msg, _globalConfigPath, mcpRegistry) {
@@ -3228,7 +3629,7 @@ async function handleMcpPrompts(ws, msg, _globalConfigPath, mcpRegistry) {
     });
     send(ws, { type: "mcp.prompts", payload: { name: serverName, prompts } });
   } catch (err) {
-    sendContentError(ws, "prompts", serverName, errorMessage(err));
+    sendContentError(ws, "prompts", serverName, errorMessage2(err));
   }
 }
 async function handleMcpResourceRead(ws, msg, _globalConfigPath, mcpRegistry) {
@@ -3244,7 +3645,7 @@ async function handleMcpResourceRead(ws, msg, _globalConfigPath, mcpRegistry) {
     );
     send(ws, { type: "mcp.content.selected", payload: insertion });
   } catch (err) {
-    sendContentError(ws, "resource.read", serverName, errorMessage(err));
+    sendContentError(ws, "resource.read", serverName, errorMessage2(err));
   }
 }
 async function handleMcpPromptGet(ws, msg, _globalConfigPath, mcpRegistry) {
@@ -3260,7 +3661,7 @@ async function handleMcpPromptGet(ws, msg, _globalConfigPath, mcpRegistry) {
     );
     send(ws, { type: "mcp.content.selected", payload: insertion });
   } catch (err) {
-    sendContentError(ws, "prompt.get", serverName, errorMessage(err));
+    sendContentError(ws, "prompt.get", serverName, errorMessage2(err));
   }
 }
 function payloadRecord(msg) {
@@ -3288,14 +3689,14 @@ function promptArguments(value) {
 function sendContentError(ws, action, name2, error) {
   send(ws, { type: "mcp.content.error", payload: { action, name: name2, error } });
 }
-function errorMessage(err) {
+function errorMessage2(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
 // src/server/memory-handlers.ts
 function isSuperMemoryStore(store) {
   const s = store;
-  return typeof s.stats === "function" && typeof s.listSuper === "function" && typeof s.getSuperMemory === "function" && typeof s.updateSuperMemory === "function" && typeof s.deleteSuperMemory === "function";
+  return typeof s.stats === "function" && typeof s.listSuper === "function" && typeof s.getSuperMemory === "function" && typeof s.updateSuperMemory === "function" && typeof s.deleteSuperMemory === "function" && typeof s.acceptCandidate === "function" && typeof s.rejectCandidate === "function";
 }
 function requiresSuperMemory(command) {
   return `\`${command}\` requires the Super Memory backend (superMemory.enabled).`;
@@ -3419,6 +3820,7 @@ async function handleSuperMemoryRemember(ws, msg, memoryStore) {
       importance: payload["importance"],
       confidence: payload["confidence"],
       freshness: payload["freshness"],
+      audience: payload["audience"],
       supersedes: payload["supersedes"],
       contradicts: payload["contradicts"]
     });
@@ -3432,18 +3834,172 @@ async function handleSuperMemoryDelete(ws, msg, memoryStore) {
     send(ws, { type: "memory.super.delete", payload: { success: false, message: requiresSuperMemory("memory.super.delete") } });
     return;
   }
-  const { id, reason } = msg.payload;
+  const { id, reason, neverInject } = msg.payload;
   if (!id) {
     send(ws, { type: "memory.super.delete", payload: { success: false, message: "id is required" } });
     return;
   }
   try {
-    await memoryStore.deleteSuperMemory(id, reason);
+    if (neverInject === true) await memoryStore.deleteSuperMemory(id, reason, { neverInject: true });
+    else await memoryStore.deleteSuperMemory(id, reason);
     send(ws, { type: "memory.super.delete", payload: { success: true, message: `Deleted memory "${id}".` } });
   } catch (err) {
     send(ws, { type: "memory.super.delete", payload: { success: false, message: errMessage(err) } });
   }
 }
+async function handleSuperMemoryRecover(ws, msg, memoryStore) {
+  if (!isSuperMemoryStore(memoryStore)) {
+    send(ws, { type: "memory.super.recover", payload: { error: requiresSuperMemory("memory.super.recover") } });
+    return;
+  }
+  const payload = msg.payload;
+  const id = payload["id"];
+  if (!id) {
+    send(ws, { type: "memory.super.recover", payload: { error: "id is required" } });
+    return;
+  }
+  const reason = payload["reason"];
+  try {
+    const preExisting = await memoryStore.getSuperMemory(id);
+    if (!preExisting) {
+      send(ws, { type: "memory.super.recover", payload: { error: `Super Memory "${id}" not found.` } });
+      return;
+    }
+    if (preExisting.status === "active") {
+      send(ws, { type: "memory.super.recover", payload: { recovered: true, memory: preExisting, noop: true } });
+      return;
+    }
+    const memory = await memoryStore.recoverSuperMemory(id, reason);
+    const noop = memory.id !== id;
+    const response = { recovered: true, memory };
+    if (noop) {
+      response["activeId"] = memory.id;
+      response["noop"] = true;
+    }
+    send(ws, { type: "memory.super.recover", payload: response });
+  } catch (err) {
+    send(ws, { type: "memory.super.recover", payload: { error: errMessage(err) } });
+  }
+}
+async function handleSuperMemoryCandidateResolve(ws, msg, memoryStore) {
+  if (!isSuperMemoryStore(memoryStore)) {
+    send(ws, {
+      type: "memory.super.candidateResolve",
+      payload: { error: requiresSuperMemory("memory.super.candidateResolve") }
+    });
+    return;
+  }
+  const payload = msg.payload;
+  const candidateId = payload["candidateId"];
+  const action = payload["action"];
+  if (!candidateId) {
+    send(ws, {
+      type: "memory.super.candidateResolve",
+      payload: { error: "candidateId is required" }
+    });
+    return;
+  }
+  if (action !== "accept" && action !== "reject") {
+    send(ws, {
+      type: "memory.super.candidateResolve",
+      payload: { error: 'action must be "accept" or "reject"' }
+    });
+    return;
+  }
+  const reason = payload["reason"];
+  try {
+    let candidate;
+    if (action === "accept") {
+      const accepted = await memoryStore.acceptCandidate(candidateId);
+      candidate = accepted ? { id: accepted.id, status: accepted.status ?? "active" } : void 0;
+    } else {
+      const rejected = await memoryStore.rejectCandidate(
+        candidateId,
+        reason ?? "Rejected via WebUI"
+      );
+      candidate = rejected ? { id: candidateId, status: "rejected" } : void 0;
+    }
+    if (!candidate) {
+      send(ws, {
+        type: "memory.super.candidateResolve",
+        payload: { error: `Candidate "${candidateId}" not found` }
+      });
+      return;
+    }
+    send(ws, {
+      type: "memory.super.candidateResolve",
+      payload: { candidate, resolvedAction: action }
+    });
+  } catch (err) {
+    send(ws, {
+      type: "memory.super.candidateResolve",
+      payload: { error: errMessage(err) }
+    });
+  }
+}
+async function handleSuperMemoryBackfillRecoverable(ws, msg, memoryStore) {
+  if (!isSuperMemoryStore(memoryStore)) {
+    send(ws, {
+      type: "memory.super.backfillRecoverable",
+      payload: { error: requiresSuperMemory("memory.super.backfillRecoverable") }
+    });
+    return;
+  }
+  const payload = msg.payload ?? {};
+  const apply = payload["apply"] === true;
+  const rawFilter = payload["filter"] ?? {};
+  const filter = {};
+  if (Array.isArray(rawFilter["kinds"])) filter.kinds = rawFilter["kinds"];
+  if (Array.isArray(rawFilter["scopes"])) filter.scopes = rawFilter["scopes"];
+  if (typeof rawFilter["updatedAfter"] === "string") filter.updatedAfter = rawFilter["updatedAfter"];
+  if (typeof rawFilter["updatedBefore"] === "string") filter.updatedBefore = rawFilter["updatedBefore"];
+  try {
+    const report = await memoryStore.backfillRecoverable({
+      apply,
+      ...Object.keys(filter).length > 0 ? { filter } : {}
+    });
+    send(ws, {
+      type: "memory.super.backfillRecoverable",
+      payload: {
+        examined: report.examined,
+        recovered: report.recovered,
+        recoverable: report.recoverable,
+        dryRun: !apply
+      }
+    });
+  } catch (err) {
+    send(ws, {
+      type: "memory.super.backfillRecoverable",
+      payload: { error: errMessage(err) }
+    });
+  }
+}
+async function handleSuperMemoryForFile(ws, msg, memoryStore) {
+  if (!isSuperMemoryStore(memoryStore)) {
+    send(ws, {
+      type: "memory.super.forFile",
+      payload: { error: requiresSuperMemory("memory.super.forFile") }
+    });
+    return;
+  }
+  const payload = msg.payload ?? {};
+  const filePath = payload["filePath"];
+  if (!filePath) {
+    send(ws, { type: "memory.super.forFile", payload: { error: "filePath is required" } });
+    return;
+  }
+  try {
+    const response = await memoryStore.findMemoriesForFile(filePath, {
+      ...typeof payload["lineStart"] === "number" ? { lineStart: payload["lineStart"] } : {},
+      ...typeof payload["lineEnd"] === "number" ? { lineEnd: payload["lineEnd"] } : {},
+      ...typeof payload["limit"] === "number" ? { limit: payload["limit"] } : {},
+      ...payload["includeDeleted"] === true ? { includeDeleted: true } : {}
+    });
+    send(ws, { type: "memory.super.forFile", payload: response });
+  } catch (err) {
+    send(ws, { type: "memory.super.forFile", payload: { error: errMessage(err) } });
+  }
+}
 
 // src/server/open-browser.ts
 import { spawn } from "node:child_process";
@@ -3502,16 +4058,16 @@ function getSurfaceDefaultPorts(surface) {
   return { ...SURFACE_DEFAULT_PORTS[surface] };
 }
 function isPortFree(host, port) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve12) => {
     const srv = net.createServer();
-    srv.once("error", () => resolve10(false));
+    srv.once("error", () => resolve12(false));
     srv.once("listening", () => {
-      srv.close(() => resolve10(true));
+      srv.close(() => resolve12(true));
     });
     try {
       srv.listen(port, host);
     } catch {
-      resolve10(false);
+      resolve12(false);
     }
   });
 }
@@ -3738,17 +4294,17 @@ async function handlePromptsRecent(ws, ctx) {
 }
 
 // src/server/provider-config-standalone.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 import { DefaultSecretVault } from "@wrongstack/core";
 
 // src/server/provider-config-io.ts
-import * as fs7 from "node:fs/promises";
+import * as fs8 from "node:fs/promises";
 import { ConfigError, atomicWrite as atomicWrite4 } from "@wrongstack/core";
 import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
 async function loadSavedProviders(configPath, vault) {
   let raw;
   try {
-    raw = await fs7.readFile(configPath, "utf8");
+    raw = await fs8.readFile(configPath, "utf8");
   } catch {
     return {};
   }
@@ -3765,7 +4321,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 ConfigError({
@@ -3799,7 +4355,7 @@ async function saveProviders(configPath, vault, providers) {
 
 // src/server/provider-config-standalone.ts
 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),
@@ -3809,6 +4365,10 @@ function createProviderConfigIO(configPath) {
 
 // src/server/provider-keys.ts
 import { expectDefined } from "@wrongstack/core";
+import {
+  buildProviderConfigFromPreset,
+  resolvePresetForAlias
+} from "@wrongstack/providers";
 function normalizeKeys(cfg) {
   if (Array.isArray(cfg.apiKeys) && cfg.apiKeys.length > 0) {
     return cfg.apiKeys.map((k) => ({ ...k }));
@@ -3837,8 +4397,28 @@ function maskedKey(key) {
   if (key.length <= 8) return "\u2022".repeat(key.length);
   return `${key.slice(0, 4)}\u2026${key.slice(-4)}`;
 }
+function hydratePresetConfig(providerId, dest) {
+  const preset = resolvePresetForAlias(providerId);
+  if (!preset) return void 0;
+  const template = buildProviderConfigFromPreset(preset);
+  if (!dest.type) dest.type = preset.id;
+  if (!dest.family) dest.family = preset.family;
+  if (dest.baseUrl === void 0) dest.baseUrl = template.baseUrl;
+  if (!dest.envVars || dest.envVars.length === 0) dest.envVars = template.envVars;
+  if (!dest.models || dest.models.length === 0) dest.models = template.models;
+  if (template.customModels && (!dest.customModels || Object.keys(dest.customModels).length === 0)) {
+    dest.customModels = template.customModels;
+  }
+  if (template.quirks && dest.quirks === void 0) dest.quirks = template.quirks;
+  return preset.id;
+}
 function upsertKey(providers, providerId, label, apiKey, nowIso) {
-  const existing = providers[providerId] ?? { type: providerId };
+  let existing = providers[providerId];
+  if (!existing) {
+    existing = { type: providerId };
+    const presetId = hydratePresetConfig(providerId, existing);
+    if (presetId) existing.type = presetId;
+  }
   const keys = normalizeKeys(existing);
   const idx = keys.findIndex((k) => k.label === label);
   if (idx >= 0) {
@@ -3888,6 +4468,8 @@ function addProvider(providers, payload, nowIso) {
     family: payload.family,
     baseUrl: payload.baseUrl
   };
+  const presetId = hydratePresetConfig(payload.id, newProv);
+  if (presetId) newProv.type = presetId;
   if (payload.apiKey) {
     newProv.apiKeys = [{ label: "default", apiKey: payload.apiKey, createdAt: nowIso }];
     newProv.activeKey = "default";
@@ -4054,7 +4636,7 @@ var SddBoardWebSocketHandler = class {
 };
 
 // src/server/sdd-wizard-wiring.ts
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import {
   DefaultTaskStore,
@@ -4154,7 +4736,7 @@ function buildSddWizardDeps(opts) {
     makeDriver: () => new SddInterviewDriver({
       specStore: new SpecStore({ baseDir: opts.paths.projectSpecs }),
       graphStore: new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs }),
-      sessionPath: path9.join(opts.paths.projectDir, "sdd-wizard-session.json")
+      sessionPath: path10.join(opts.paths.projectDir, "sdd-wizard-session.json")
     }),
     runInterviewTurn: (prompt) => runIsolatedTurn(prompt, "Spec Architect"),
     startRun: async (driver, { parallelSlots, defaultModel, defaultProvider, fallbackModels, worktrees: useWorktrees }) => {
@@ -4356,8 +4938,8 @@ function toSessionHistoryEntries(summaries, currentSessionId) {
 }
 
 // src/server/shell-open.ts
-import * as fs8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as fs9 from "node:fs/promises";
+import * as path11 from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 var METACHAR_REGEX = /[&|<>^"'`'\n\r]/;
 function shellQuote(s) {
@@ -4365,8 +4947,8 @@ function shellQuote(s) {
 }
 async function handleShellOpen(req, logger) {
   try {
-    const resolved = path10.resolve(req.path);
-    await fs8.access(resolved);
+    const resolved = path11.resolve(req.path);
+    await fs9.access(resolved);
     if (METACHAR_REGEX.test(resolved)) {
       return { success: false, message: "Path contains unsupported characters." };
     }
@@ -4417,12 +4999,13 @@ async function handleShellOpen(req, logger) {
 }
 
 // src/server/skills-handlers.ts
-import { promises as fs9 } from "node:fs";
-import path11 from "node:path";
+import { promises as fs10 } from "node:fs";
+import path12 from "node:path";
 import { atomicWrite as atomicWrite5 } from "@wrongstack/core";
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
 
 // src/server/ws-payload-validation.ts
+import { FORBIDDEN_PROTO_KEYS } from "@wrongstack/core/utils";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4627,12 +5210,24 @@ var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   "hqRawContent",
   "fallbackAuto",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "breakerEnabled",
-  "debugStream"
+  "debugStream",
+  // Chimera + auto-review master toggles
+  "chimeraEnabled",
+  "autoReviewEnabled",
+  "showModelReasoning"
+]);
+var STRING_ARRAY_PREF_KEYS = /* @__PURE__ */ new Set([
+  "fallbackModels",
+  "favoriteModels",
+  // Auto-review explicit fallback chain (derived when fallbackProfile is unset;
+  // surfaced for visibility/override).
+  "autoReviewFallbackModels"
 ]);
-var STRING_ARRAY_PREF_KEYS = /* @__PURE__ */ new Set(["fallbackModels", "favoriteModels"]);
 var STRING_ARRAY_RECORD_PREF_KEYS = /* @__PURE__ */ new Set(["fallbackProfiles"]);
 var MODEL_MATRIX_PREF_KEYS = /* @__PURE__ */ new Set(["modelMatrix"]);
+var BOOLEAN_RECORD_PREF_KEYS = /* @__PURE__ */ new Set(["pluginsEnabled"]);
 var NUMBER_PREF_KEYS = /* @__PURE__ */ new Set([
   "autonomyDelayMs",
   "autoProceedMaxIterations",
@@ -4640,7 +5235,12 @@ var NUMBER_PREF_KEYS = /* @__PURE__ */ new Set([
   "maxConcurrent",
   "enhanceDelayMs",
   "tgLongToolMs",
-  "breakerAutoKillResetMs"
+  "breakerAutoKillResetMs",
+  // Chimera + auto-review numeric knobs
+  "chimeraMaxFiles",
+  "autoReviewDebounceMs",
+  "autoReviewMaxFilesPerBatch",
+  "autoReviewMaxConcurrentReviews"
 ]);
 var STRING_PREF_KEYS = /* @__PURE__ */ new Set([
   "hqUrl",
@@ -4649,7 +5249,13 @@ var STRING_PREF_KEYS = /* @__PURE__ */ new Set([
   "thinkingWord",
   "refinerProvider",
   "refinerModel",
-  "refinerFallbackProfile"
+  "refinerFallbackProfile",
+  // Chimera + auto-review override strings
+  "chimeraProvider",
+  "chimeraModel",
+  "autoReviewProvider",
+  "autoReviewModel",
+  "autoReviewFallbackProfile"
 ]);
 var ENUM_PREF_KEYS = {
   autonomy: AUTONOMY_VALUES,
@@ -4664,36 +5270,39 @@ var ENUM_PREF_KEYS = {
   cacheTtl: CACHE_TTL_VALUES,
   statuslineMode: /* @__PURE__ */ new Set(["minimum", "detailed", "no-color"]),
   animationStyle: /* @__PURE__ */ new Set(["rainbow", "wave", "pulse", "dots", "breathe", "cycle"]),
-  fsAccess: /* @__PURE__ */ new Set(["unrestricted", "project"])
+  fsAccess: /* @__PURE__ */ new Set(["unrestricted", "project"]),
+  // Chimera autoFix + auto-review cascade threshold
+  chimeraAutoFix: /* @__PURE__ */ new Set(["off", "ask", "auto"]),
+  autoReviewCascadeOn: /* @__PURE__ */ new Set(["off", "critical", "high"])
 };
-function validateModelRuntimeValue(modelRuntime, path23) {
+function validateModelRuntimeValue(modelRuntime, path24) {
   const reasoning = modelRuntime["reasoning"];
   if (reasoning !== void 0) {
-    if (!isRecord(reasoning)) return `${path23}.reasoning must be an object when provided`;
+    if (!isRecord(reasoning)) return `${path24}.reasoning must be an object when provided`;
     const mode = reasoning["mode"];
     const effort = reasoning["effort"];
     const preserve = reasoning["preserve"];
     if (mode !== void 0 && (typeof mode !== "string" || !REASONING_MODE_VALUES.has(mode))) {
-      return `${path23}.reasoning.mode must be one of: ${Array.from(REASONING_MODE_VALUES).join(", ")}`;
+      return `${path24}.reasoning.mode must be one of: ${Array.from(REASONING_MODE_VALUES).join(", ")}`;
     }
     if (effort !== void 0 && (typeof effort !== "string" || !REASONING_EFFORT_VALUES.has(effort))) {
-      return `${path23}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
+      return `${path24}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
     }
     if (preserve !== void 0 && typeof preserve !== "boolean") {
-      return `${path23}.reasoning.preserve must be a boolean when provided`;
+      return `${path24}.reasoning.preserve must be a boolean when provided`;
     }
   }
   const cache = modelRuntime["cache"];
   if (cache !== void 0) {
-    if (!isRecord(cache)) return `${path23}.cache must be an object when provided`;
+    if (!isRecord(cache)) return `${path24}.cache must be an object when provided`;
     const ttl = cache["ttl"];
     if (ttl !== void 0 && (typeof ttl !== "string" || !CACHE_TTL_VALUES.has(ttl) || ttl === "default")) {
-      return `${path23}.cache.ttl must be one of: 5m, 1h`;
+      return `${path24}.cache.ttl must be one of: 5m, 1h`;
     }
   }
   const parameters = modelRuntime["parameters"];
   if (parameters !== void 0 && !isRecord(parameters)) {
-    return `${path23}.parameters must be an object when provided`;
+    return `${path24}.parameters must be an object when provided`;
   }
   return null;
 }
@@ -4715,6 +5324,16 @@ function validatePreferenceValue(key, value) {
       (v) => Array.isArray(v) && v.every((item) => typeof item === "string")
     ) ? null : `prefs.update payload.${key} must be an object of string arrays`;
   }
+  if (BOOLEAN_RECORD_PREF_KEYS.has(key)) {
+    if (!isRecord(value) || !Object.values(value).every((v) => typeof v === "boolean")) {
+      return `prefs.update payload.${key} must be an object of booleans`;
+    }
+    const badKey = Object.keys(value).find((k) => FORBIDDEN_PROTO_KEYS.has(k));
+    if (badKey) {
+      return `prefs.update payload.${key} contains a forbidden key: ${badKey}`;
+    }
+    return null;
+  }
   if (MODEL_MATRIX_PREF_KEYS.has(key)) {
     if (!isRecord(value)) return `prefs.update payload.${key} must be an object`;
     for (const entry of Object.values(value)) {
@@ -4736,7 +5355,10 @@ function validatePreferenceValue(key, value) {
         return `prefs.update payload.${key}.modelRuntime must be an object when provided`;
       }
       if (isRecord(modelRuntime)) {
-        const runtimeError = validateModelRuntimeValue(modelRuntime, `prefs.update payload.${key}.modelRuntime`);
+        const runtimeError = validateModelRuntimeValue(
+          modelRuntime,
+          `prefs.update payload.${key}.modelRuntime`
+        );
         if (runtimeError) return runtimeError;
       }
       if (model === void 0 && fallbackProfile === void 0 && modelRuntime === void 0) {
@@ -4973,8 +5595,8 @@ function validateShellOpenPayload(payload) {
   if (!isRecord(payload)) {
     return { ok: false, message: "shell.open payload must be an object with string path" };
   }
-  const path23 = payload["path"];
-  if (typeof path23 !== "string" || path23.trim().length === 0) {
+  const path24 = payload["path"];
+  if (typeof path24 !== "string" || path24.trim().length === 0) {
     return { ok: false, message: "shell.open payload.path must be a non-empty string" };
   }
   const target = payload["target"];
@@ -4987,7 +5609,7 @@ function validateShellOpenPayload(payload) {
   return {
     ok: true,
     value: {
-      path: path23,
+      path: path24,
       ...target !== void 0 ? { target } : {}
     }
   };
@@ -4996,14 +5618,14 @@ function validateGitDiffPayload(payload) {
   if (!isRecord(payload)) {
     return { ok: false, message: "git.diff payload must be an object" };
   }
-  const path23 = payload["path"];
-  if (path23 === void 0 || path23 === null) {
+  const path24 = payload["path"];
+  if (path24 === void 0 || path24 === null) {
     return { ok: true, value: { path: "" } };
   }
-  if (typeof path23 !== "string") {
+  if (typeof path24 !== "string") {
     return { ok: false, message: "git.diff payload.path must be a string when provided" };
   }
-  return { ok: true, value: { path: path23 } };
+  return { ok: true, value: { path: path24 } };
 }
 function validateProjectsAddPayload(payload) {
   if (!isRecord(payload)) {
@@ -5225,19 +5847,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 fs9.readFile(entry.path, "utf8");
-    const skillDir = path11.dirname(entry.path);
+    const body = await fs10.readFile(entry.path, "utf8");
+    const skillDir = path12.dirname(entry.path);
     let relatedFiles = [];
     try {
-      const files = await fs9.readdir(skillDir);
-      relatedFiles = files.filter((f) => f !== path11.basename(entry.path)).map((f) => path11.join(skillDir, f));
+      const files = await fs10.readdir(skillDir);
+      relatedFiles = files.filter((f) => f !== path12.basename(entry.path)).map((f) => path12.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 fs9.readFile(e.path, "utf8");
+          const content = await fs10.readFile(e.path, "utf8");
           return [e.name, content.toLowerCase().includes(nameLower)];
         } catch {
           return [e.name, false];
@@ -5327,20 +5949,20 @@ async function handleSkillsCreate(ws, ctx, msg) {
   }
   const createPayload = parsed.value;
   try {
-    const targetDir = createPayload.scope === "global" ? path11.join(
-      ctx.globalSkillsDir ?? path11.join(wstackGlobalRoot(), "skills"),
+    const targetDir = createPayload.scope === "global" ? path12.join(
+      ctx.globalSkillsDir ?? path12.join(wstackGlobalRoot(), "skills"),
       createPayload.name.trim()
-    ) : path11.join(
-      ctx.projectSkillsDir ?? path11.join(ctx.projectRoot, ".wrongstack", "skills"),
+    ) : path12.join(
+      ctx.projectSkillsDir ?? path12.join(ctx.projectRoot, ".wrongstack", "skills"),
       createPayload.name.trim()
     );
     try {
-      await fs9.access(targetDir);
+      await fs10.access(targetDir);
       send(ws, { type: "skills.created", payload: { success: false, error: `Skill "${createPayload.name}" already exists` } });
       return;
     } catch {
     }
-    await fs9.mkdir(targetDir, { recursive: true });
+    await fs10.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);
@@ -5388,13 +6010,13 @@ ${trigger}
       "- `bug-hunter` \u2014 for systematic bug detection patterns",
       "- `output-standards` \u2014 for standardized `<nextsteps>` formatting"
     ].join("\n");
-    await atomicWrite5(path11.join(targetDir, "SKILL.md"), skillContent);
+    await atomicWrite5(path12.join(targetDir, "SKILL.md"), skillContent);
     send(ws, {
       type: "skills.created",
       payload: {
         success: true,
         error: null,
-        skill: { name: createPayload.name.trim(), path: path11.join(targetDir, "SKILL.md"), scope: createPayload.scope }
+        skill: { name: createPayload.name.trim(), path: path12.join(targetDir, "SKILL.md"), scope: createPayload.scope }
       }
     });
   } catch (err) {
@@ -5671,7 +6293,7 @@ function estimateContextBreakdown(input) {
 }
 
 // src/server/worktree-ws-handler.ts
-import { join as join8, resolve as resolve6, sep as sep3 } from "node:path";
+import { join as join9, resolve as resolve6, sep as sep3 } from "node:path";
 import { WorktreeManager as WorktreeManager3 } from "@wrongstack/core";
 import { cleanupStaleSddWorktrees as cleanupStaleSddWorktrees2 } from "@wrongstack/sdd";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
@@ -5732,7 +6354,7 @@ var WorktreeWebSocketHandler = class {
   // ── orphan management ─────────────────────────────────────────────────────
   /** Absolute managed-worktrees root for this project. */
   worktreesRoot() {
-    return resolve6(join8(this.management.projectRoot, ".wrongstack", "worktrees"));
+    return resolve6(join9(this.management.projectRoot, ".wrongstack", "worktrees"));
   }
   /** True iff `dir` resolves strictly inside the managed worktrees root. */
   underRoot(dir) {
@@ -6003,7 +6625,7 @@ var WorktreeWebSocketHandler = class {
 };
 
 // src/server/server-runtime.ts
-import * as path13 from "node:path";
+import * as path15 from "node:path";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer } from "ws";
@@ -6045,12 +6667,103 @@ function registerShutdownHandlers(res) {
 }
 
 // src/server/setup-events.ts
-import * as fs10 from "node:fs/promises";
 import { watch as fsWatch } from "node:fs";
-import * as path12 from "node:path";
+import * as fs11 from "node:fs/promises";
+import * as path14 from "node:path";
+import { getBoard, getKanbanDir, recordTaskFileActivity } from "@wrongstack/kanban";
+
+// src/server/codemap-telemetry.ts
+import * as path13 from "node:path";
+var TOOL_OPERATION = {
+  read: "read",
+  read_file: "read",
+  view: "read",
+  write: "write",
+  write_file: "write",
+  create_file: "write",
+  edit: "edit",
+  replace: "edit",
+  patch: "edit",
+  apply_patch: "edit",
+  delete: "delete",
+  delete_file: "delete",
+  remove: "delete",
+  unlink: "delete",
+  grep: "search",
+  search: "search",
+  codebase_search: "search",
+  "codebase-search": "search"
+};
+function numberField(input, names) {
+  for (const name2 of names) {
+    const value = input[name2];
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+  }
+  return void 0;
+}
+function normalizeTarget(projectRoot, filePath) {
+  return path13.normalize(path13.isAbsolute(filePath) ? filePath : path13.resolve(projectRoot, filePath));
+}
+function normalizeCodeMapFileTarget(projectRoot, filePath, operation = "edit", line, endLine) {
+  return {
+    filePath: normalizeTarget(projectRoot, filePath),
+    operation: operation === "rename" ? "edit" : operation,
+    ...line ? { line } : {},
+    ...endLine ? { endLine } : {}
+  };
+}
+function patchTargets(patch) {
+  const targets = [];
+  for (const line of patch.split(/\r?\n/)) {
+    const match = /^\+\+\+\s+(?:b\/)?(.+?)(?:\t.*)?$/.exec(line);
+    const target = match?.[1]?.trim();
+    if (target && target !== "/dev/null") targets.push(target);
+  }
+  return targets;
+}
+function extractCodeMapFileTargets(projectRoot, toolName, rawInput) {
+  const operation = TOOL_OPERATION[toolName.toLowerCase()];
+  if (!operation || !rawInput || typeof rawInput !== "object" || Array.isArray(rawInput)) return [];
+  const input = rawInput;
+  const rawPaths = [];
+  for (const key of ["path", "file", "filePath", "target"]) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) rawPaths.push(value.trim());
+  }
+  const files = input["files"];
+  if (Array.isArray(files)) {
+    for (const value of files)
+      if (typeof value === "string" && value.trim()) rawPaths.push(value.trim());
+  } else if (typeof files === "string" && files.trim() && !/[?*{}[\]]/.test(files)) {
+    rawPaths.push(files.trim());
+  }
+  if ((toolName === "patch" || toolName === "apply_patch") && typeof input["patch"] === "string") {
+    rawPaths.push(...patchTargets(input["patch"]));
+  }
+  const line = numberField(input, ["line", "offset", "startLine", "start_line", "line_start"]);
+  const explicitEnd = numberField(input, ["endLine", "end_line", "line_end"]);
+  const limit = numberField(input, ["limit"]);
+  const endLine = explicitEnd ?? (line && limit ? line + limit - 1 : void 0);
+  const seen = /* @__PURE__ */ new Set();
+  const targets = [];
+  for (const rawPath of rawPaths) {
+    const filePath = normalizeTarget(projectRoot, rawPath);
+    if (seen.has(filePath)) continue;
+    seen.add(filePath);
+    targets.push({
+      filePath,
+      operation,
+      ...line ? { line } : {},
+      ...endLine ? { endLine } : {}
+    });
+  }
+  return targets;
+}
+
+// src/server/setup-events.ts
 function statusProjectHashFromWatchFilename(projectsDir, filename) {
   const raw = String(filename);
-  const relative4 = path12.isAbsolute(raw) ? path12.relative(projectsDir, raw) : raw;
+  const relative4 = path14.isAbsolute(raw) ? path14.relative(projectsDir, raw) : raw;
   const parts = relative4.split(/[\\/]+/).filter(Boolean);
   if (parts.length < 2) return null;
   if (parts[parts.length - 1] !== "status.json") return null;
@@ -6061,12 +6774,76 @@ function shouldLogWatcherStats() {
   return value === "1" || value === "true" || value === "yes" || value === "on";
 }
 function setupEvents(deps2) {
-  const { events, broadcast: broadcast2, clients, config, context, pendingConfirms, globalConfigPath, sessionBridge, wpaths, watcherMetrics, onFleetBroadcaster } = deps2;
+  const {
+    events,
+    broadcast: broadcast2,
+    clients,
+    config,
+    context,
+    pendingConfirms,
+    globalConfigPath,
+    sessionBridge,
+    wpaths,
+    watcherMetrics,
+    onFleetBroadcaster
+  } = deps2;
   const disposers = [];
   let disposed = false;
   const on = (event, listener) => {
     disposers.push(events.on(event, listener));
   };
+  const conversationState = context.state;
+  if (typeof conversationState?.onChange === "function") {
+    disposers.push(
+      conversationState.onChange((change) => {
+        if (change.kind !== "todos_replaced") return;
+        broadcast2(clients, {
+          type: "todos.updated",
+          payload: {
+            sessionId: context.session?.id ?? "",
+            todos: [...change.todos],
+            revision: conversationState.revision
+          }
+        });
+      })
+    );
+  }
+  let kanbanWatcher = null;
+  let kanbanDebounce = null;
+  const projectRoot = context.projectRoot;
+  if (projectRoot) {
+    try {
+      const kanbanDir = getKanbanDir(projectRoot);
+      kanbanWatcher = fsWatch(kanbanDir, { persistent: false }, (_eventType, filename) => {
+        const name2 = filename?.toString();
+        if (!name2?.endsWith(".json")) return;
+        const boardId = name2.slice(0, -5);
+        if (kanbanDebounce) clearTimeout(kanbanDebounce);
+        kanbanDebounce = setTimeout(async () => {
+          try {
+            const board = await getBoard(projectRoot, boardId);
+            if (board) {
+              broadcast2(clients, {
+                type: "kanban.get",
+                // Wrap in the { board } envelope like every other kanban
+                // broadcast so the client's isBoardEnvelope path handles it
+                // without hijacking another tab's activeBoardId.
+                payload: { success: true, data: { board } }
+              });
+            }
+          } catch {
+          }
+        }, 60);
+      });
+      kanbanWatcher.on("error", () => kanbanWatcher?.close());
+      disposers.push(() => {
+        if (kanbanDebounce) clearTimeout(kanbanDebounce);
+        kanbanWatcher?.close();
+        kanbanWatcher = null;
+      });
+    } catch {
+    }
+  }
   const currentSessionId = () => context.session?.id ?? "";
   const sessionPayload2 = (payload) => {
     const provided = payload["sessionId"];
@@ -6092,7 +6869,11 @@ function setupEvents(deps2) {
   on("iteration.completed", (e) => {
     broadcast2(clients, {
       type: "iteration.completed",
-      payload: sessionPayload2({ sessionId: e.sessionId, index: e.index, totalIterations: e.index + 1 })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        index: e.index,
+        totalIterations: e.index + 1
+      })
     });
   });
   on("iteration.limit_reached", (e) => {
@@ -6106,10 +6887,16 @@ function setupEvents(deps2) {
     });
   });
   on("provider.text_delta", (e) => {
-    broadcast2(clients, { type: "provider.text_delta", payload: sessionPayload2({ sessionId: e.sessionId, text: e.text, messageId: "current" }) });
+    broadcast2(clients, {
+      type: "provider.text_delta",
+      payload: sessionPayload2({ sessionId: e.sessionId, text: e.text, messageId: "current" })
+    });
   });
   on("provider.thinking_delta", (e) => {
-    broadcast2(clients, { type: "provider.thinking_delta", payload: sessionPayload2({ sessionId: e.sessionId, text: e.text }) });
+    broadcast2(clients, {
+      type: "provider.thinking_delta",
+      payload: sessionPayload2({ sessionId: e.sessionId, text: e.text })
+    });
   });
   on("provider.stream_error", (e) => {
     broadcast2(clients, {
@@ -6120,7 +6907,17 @@ function setupEvents(deps2) {
   on("tool.started", (e) => {
     broadcast2(clients, {
       type: "tool.started",
-      payload: sessionPayload2({ sessionId: e.sessionId, id: e.id, name: e.name, input: e.input, messageId: `tool_${e.id}` })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        traceId: e.traceId,
+        agentId: e.agentId,
+        agentName: e.agentName,
+        id: e.id,
+        name: e.name,
+        input: e.input,
+        fileTargets: extractCodeMapFileTargets(context.projectRoot, e.name, e.input),
+        messageId: `tool_${e.id}`
+      })
     });
     appendForCurrentSession(e.sessionId, {
       type: "tool_call_start",
@@ -6131,13 +6928,37 @@ function setupEvents(deps2) {
     });
   });
   on("tool.progress", (e) => {
+    const rawProgressPath = e.event.path ?? (typeof e.event.data?.["path"] === "string" ? e.event.data["path"] : void 0);
+    const progressTarget = rawProgressPath ? normalizeCodeMapFileTarget(
+      context.projectRoot,
+      rawProgressPath,
+      e.event.operation ?? "edit",
+      e.event.line,
+      e.event.endLine
+    ) : void 0;
     broadcast2(clients, {
       type: "tool.progress",
       // Nested `event` shape — the client handler reads `payload.event?.text`
       // and early-returns on a falsy text, so a flat { eventType, text } payload
       // makes live tool progress (bash streaming, partial_output, warnings)
       // never render. Must match WSToolProgress and the CLI server.
-      payload: sessionPayload2({ sessionId: e.sessionId, id: e.id, name: e.name, event: { type: e.event.type, text: e.event.text, data: e.event.data } })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        traceId: e.traceId,
+        agentId: e.agentId,
+        agentName: e.agentName,
+        id: e.id,
+        name: e.name,
+        event: {
+          type: e.event.type,
+          text: e.event.text,
+          data: e.event.data,
+          path: progressTarget?.filePath,
+          operation: e.event.operation,
+          line: progressTarget?.line,
+          endLine: progressTarget?.endLine
+        }
+      })
     });
     appendForCurrentSession(e.sessionId, {
       type: "tool_progress",
@@ -6154,7 +6975,23 @@ function setupEvents(deps2) {
   on("tool.executed", (e) => {
     broadcast2(clients, {
       type: "tool.executed",
-      payload: sessionPayload2({ sessionId: e.sessionId, id: e.id, name: e.name, durationMs: e.durationMs, ok: e.ok, input: e.input, output: e.output })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        traceId: e.traceId,
+        agentId: e.agentId,
+        agentName: e.agentName,
+        id: e.id,
+        name: e.name,
+        durationMs: e.durationMs,
+        ok: e.ok,
+        input: e.input,
+        fileTargets: extractCodeMapFileTargets(context.projectRoot, e.name, e.input),
+        output: e.output,
+        outputBytes: e.outputBytes,
+        outputTokens: e.outputTokens,
+        outputLines: e.outputLines,
+        metadata: e.metadata
+      })
     });
     appendForCurrentSession(e.sessionId, {
       type: "tool_call_end",
@@ -6168,7 +7005,10 @@ function setupEvents(deps2) {
       outputTokens: e.outputTokens,
       outputLines: e.outputLines
     });
-    broadcast2(clients, { type: "todos.updated", payload: sessionPayload2({ sessionId: e.sessionId, todos: [...context.todos] }) });
+    broadcast2(clients, {
+      type: "todos.updated",
+      payload: sessionPayload2({ sessionId: e.sessionId, todos: [...context.todos] })
+    });
     const sideEffects = context.sideEffects ?? [];
     if (sideEffects.length > 0) {
       broadcast2(clients, {
@@ -6193,7 +7033,10 @@ function setupEvents(deps2) {
           if (typeof taskPath === "string" && taskPath) {
             const { loadTasks } = await import("@wrongstack/core");
             const file = await loadTasks(taskPath);
-            broadcast2(clients, { type: "tasks.updated", payload: sessionPayload2({ sessionId: e.sessionId, tasks: file?.tasks ?? [] }) });
+            broadcast2(clients, {
+              type: "tasks.updated",
+              payload: sessionPayload2({ sessionId: e.sessionId, tasks: file?.tasks ?? [] })
+            });
           }
         } catch {
         }
@@ -6202,13 +7045,39 @@ function setupEvents(deps2) {
           if (typeof planPath === "string" && planPath) {
             const { loadPlan } = await import("@wrongstack/core");
             const plan = await loadPlan(planPath);
-            broadcast2(clients, { type: "plan.updated", payload: sessionPayload2({ sessionId: e.sessionId, plan: plan ?? { version: 1, sessionId: e.sessionId ?? context.session?.id ?? "", updatedAt: (/* @__PURE__ */ new Date()).toISOString(), items: [] } }) });
+            broadcast2(clients, {
+              type: "plan.updated",
+              payload: sessionPayload2({
+                sessionId: e.sessionId,
+                plan: plan ?? {
+                  version: 1,
+                  sessionId: e.sessionId ?? context.session?.id ?? "",
+                  updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  items: []
+                }
+              })
+            });
           }
         } catch {
         }
       })();
     }
   });
+  on("file.activity", (e) => {
+    broadcast2(clients, { type: "codemap.file_event", payload: e });
+  });
+  on("file.event", (e) => {
+    if (e.scope !== "task" || !e.boardId || !e.taskId) return;
+    void recordTaskFileActivity(context.projectRoot, e.boardId, e.taskId, e).then((recorded) => {
+      if (recorded) {
+        broadcast2(clients, {
+          type: "kanban.task.activity.changed",
+          payload: { boardId: e.boardId, taskId: e.taskId }
+        });
+      }
+    }).catch(() => {
+    });
+  });
   on("tool.loop_detected", (e) => {
     broadcast2(clients, {
       type: "tool.loop_detected",
@@ -6224,7 +7093,12 @@ function setupEvents(deps2) {
   on("trust.persisted", (e) => {
     broadcast2(clients, {
       type: "trust.persisted",
-      payload: sessionPayload2({ sessionId: e.sessionId, tool: e.tool, pattern: e.pattern, decision: e.decision })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        tool: e.tool,
+        pattern: e.pattern,
+        decision: e.decision
+      })
     });
   });
   on("delegate.started", (e) => {
@@ -6266,7 +7140,12 @@ function setupEvents(deps2) {
   on("ctx.pct", (e) => {
     broadcast2(clients, {
       type: "ctx.pct",
-      payload: sessionPayload2({ sessionId: e.sessionId, load: e.load, tokens: e.tokens, maxContext: e.maxContext })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        load: e.load,
+        tokens: e.tokens,
+        maxContext: e.maxContext
+      })
     });
     broadcast2(clients, {
       type: "subagent.event",
@@ -6283,7 +7162,12 @@ function setupEvents(deps2) {
   on("ctx.max_context", (e) => {
     broadcast2(clients, {
       type: "ctx.max_context",
-      payload: sessionPayload2({ sessionId: e.sessionId, providerId: e.providerId, modelId: e.modelId, maxContext: e.maxContext })
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        providerId: e.providerId,
+        modelId: e.modelId,
+        maxContext: e.maxContext
+      })
     });
   });
   on("token.threshold", (e) => {
@@ -6299,21 +7183,46 @@ function setupEvents(deps2) {
     });
   });
   on("context.repaired", (e) => {
-    broadcast2(clients, { type: "context.repaired", payload: sessionPayload2({ sessionId: e.sessionId, removedToolUses: e.removedToolUses, removedToolResults: e.removedToolResults, removedMessages: e.removedMessages }) });
+    broadcast2(clients, {
+      type: "context.repaired",
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        removedToolUses: e.removedToolUses,
+        removedToolResults: e.removedToolResults,
+        removedMessages: e.removedMessages
+      })
+    });
   });
   on("tool.confirm_needed", (e) => {
     const id = e.toolUseId ?? `confirm_${Date.now()}`;
-    const payload = sessionPayload2({ sessionId: e.sessionId, id, toolName: e.tool?.name ?? "unknown", input: e.input, suggestedPattern: e.suggestedPattern, decisionSource: e.decisionSource, riskTier: e.riskTier });
+    const payload = sessionPayload2({
+      sessionId: e.sessionId,
+      id,
+      toolName: e.tool?.name ?? "unknown",
+      input: e.input,
+      suggestedPattern: e.suggestedPattern,
+      decisionSource: e.decisionSource,
+      riskTier: e.riskTier,
+      boundaryReason: e.boundaryReason
+    });
     pendingConfirms.set(id, {
       resolve: e.resolve,
       decisionSource: e.decisionSource,
       riskTier: e.riskTier,
+      boundaryReason: e.boundaryReason,
       payload
     });
     broadcast2(clients, { type: "tool.confirm_needed", payload });
   });
   on("error", (e) => {
-    broadcast2(clients, { type: "error", payload: sessionPayload2({ sessionId: e.sessionId, phase: e.phase, message: e.err instanceof Error ? e.err.message : String(e.err) }) });
+    broadcast2(clients, {
+      type: "error",
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        phase: e.phase,
+        message: e.err instanceof Error ? e.err.message : String(e.err)
+      })
+    });
     appendForCurrentSession(e.sessionId, {
       type: "error",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6384,6 +7293,35 @@ function setupEvents(deps2) {
       description: e.description
     });
   });
+  on("provider.status_changed", (e) => {
+    broadcast2(clients, {
+      type: "provider.status_changed",
+      payload: sessionPayload2({
+        providerId: e.providerId,
+        model: e.model,
+        oldState: e.oldState,
+        newState: e.newState,
+        reason: e.reason,
+        timestamp: e.timestamp,
+        stateExpiresAt: e.stateExpiresAt
+      })
+    });
+  });
+  on("provider.active_blocked", (e) => {
+    broadcast2(clients, {
+      type: "provider.active_blocked",
+      payload: sessionPayload2({
+        sessionId: e.sessionId,
+        providerId: e.providerId,
+        model: e.model,
+        state: e.state,
+        fallbackProviderId: e.fallbackProviderId,
+        fallbackModel: e.fallbackModel,
+        lastError: e.lastError,
+        timestamp: e.timestamp
+      })
+    });
+  });
   on("provider.error", (e) => {
     broadcast2(clients, {
       type: "provider.error",
@@ -6489,16 +7427,137 @@ function setupEvents(deps2) {
     broadcast2(clients, { type: "mailbox.agent_registered", payload });
   });
   const forwardSubagent = (kind, payload) => broadcast2(clients, { type: "subagent.event", payload: sessionPayload2({ kind, ...payload }) });
-  on("subagent.spawned", (e) => forwardSubagent("spawned", { sessionId: e.sessionId, subagentId: e.subagentId, taskId: e.taskId, name: e.name, provider: e.provider, model: e.model, description: e.description }));
-  on("subagent.task_started", (e) => forwardSubagent("task_started", { sessionId: e.sessionId, subagentId: e.subagentId, taskId: e.taskId, description: e.description }));
-  on("subagent.tool_executed", (e) => forwardSubagent("tool_executed", { sessionId: e.sessionId, subagentId: e.subagentId, toolName: e.name, durationMs: e.durationMs, ok: e.ok }));
-  on("subagent.iteration_summary", (e) => forwardSubagent("iteration_summary", { sessionId: e.sessionId, subagentId: e.subagentId, iteration: e.iteration, toolCalls: e.toolCalls, costUsd: e.costUsd, currentTool: e.currentTool, partialText: e.partialText }));
-  on("subagent.budget_warning", (e) => forwardSubagent("budget_warning", { sessionId: e.sessionId, subagentId: e.subagentId, budgetKind: e.kind, used: e.used, limit: e.limit }));
-  on("subagent.budget_extended", (e) => forwardSubagent("budget_extended", { sessionId: e.sessionId, subagentId: e.subagentId, budgetKind: e.kind, newLimit: e.newLimit, totalExtensions: e.totalExtensions }));
-  on("subagent.ctx_pct", (e) => forwardSubagent("ctx_pct", { sessionId: e.sessionId, subagentId: e.subagentId, load: e.load, tokens: e.tokens, maxContext: e.maxContext }));
-  on("subagent.task_completed", (e) => forwardSubagent("task_completed", { sessionId: e.sessionId, subagentId: e.subagentId, status: e.status, iterations: e.iterations, toolCalls: e.toolCalls, finalText: e.finalText, failureReason: e.error?.kind, error: e.error ? { kind: e.error.kind, message: e.error.message } : void 0 }));
-  on("subagent.removed", (e) => forwardSubagent("removed", { sessionId: e.sessionId, subagentId: e.subagentId, reason: e.reason }));
+  on(
+    "subagent.spawned",
+    (e) => forwardSubagent("spawned", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      taskId: e.taskId,
+      name: e.name,
+      provider: e.provider,
+      model: e.model,
+      description: e.description
+    })
+  );
+  on(
+    "subagent.task_started",
+    (e) => forwardSubagent("task_started", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      taskId: e.taskId,
+      description: e.description
+    })
+  );
+  on("subagent.tool_started", (e) => {
+    broadcast2(clients, {
+      type: "codemap.tool_started",
+      payload: {
+        sessionId: e.agentSessionId ?? e.sessionId ?? "",
+        parentSessionId: e.sessionId,
+        traceId: e.traceId,
+        agentId: e.subagentId,
+        agentName: e.agentName ?? e.subagentId,
+        id: e.id,
+        name: e.name,
+        input: e.input,
+        fileTargets: extractCodeMapFileTargets(context.projectRoot, e.name, e.input)
+      }
+    });
+  });
+  on("subagent.tool_executed", (e) => {
+    broadcast2(clients, {
+      type: "codemap.tool_executed",
+      payload: {
+        sessionId: e.agentSessionId ?? e.sessionId ?? "",
+        parentSessionId: e.sessionId,
+        traceId: e.traceId,
+        agentId: e.subagentId,
+        agentName: e.agentName ?? e.subagentId,
+        id: e.id,
+        name: e.name,
+        durationMs: e.durationMs,
+        ok: e.ok,
+        input: e.input,
+        fileTargets: extractCodeMapFileTargets(context.projectRoot, e.name, e.input),
+        output: e.output,
+        outputBytes: e.outputBytes,
+        outputTokens: e.outputTokens,
+        outputLines: e.outputLines
+      }
+    });
+    forwardSubagent("tool_executed", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      toolName: e.name,
+      durationMs: e.durationMs,
+      ok: e.ok
+    });
+  });
+  on(
+    "subagent.iteration_summary",
+    (e) => forwardSubagent("iteration_summary", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      iteration: e.iteration,
+      toolCalls: e.toolCalls,
+      costUsd: e.costUsd,
+      currentTool: e.currentTool,
+      partialText: e.partialText
+    })
+  );
+  on(
+    "subagent.budget_warning",
+    (e) => forwardSubagent("budget_warning", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      budgetKind: e.kind,
+      used: e.used,
+      limit: e.limit
+    })
+  );
+  on(
+    "subagent.budget_extended",
+    (e) => forwardSubagent("budget_extended", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      budgetKind: e.kind,
+      newLimit: e.newLimit,
+      totalExtensions: e.totalExtensions
+    })
+  );
+  on(
+    "subagent.ctx_pct",
+    (e) => forwardSubagent("ctx_pct", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      load: e.load,
+      tokens: e.tokens,
+      maxContext: e.maxContext
+    })
+  );
+  on(
+    "subagent.task_completed",
+    (e) => forwardSubagent("task_completed", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      status: e.status,
+      iterations: e.iterations,
+      toolCalls: e.toolCalls,
+      finalText: e.finalText,
+      failureReason: e.error?.kind,
+      error: e.error ? { kind: e.error.kind, message: e.error.message } : void 0
+    })
+  );
+  on(
+    "subagent.removed",
+    (e) => forwardSubagent("removed", {
+      sessionId: e.sessionId,
+      subagentId: e.subagentId,
+      reason: e.reason
+    })
+  );
   on("agent.timeline.message", (e) => {
+    const timeline = e;
     broadcast2(clients, {
       type: "agent.timeline.message",
       payload: sessionPayload2({
@@ -6510,6 +7569,7 @@ function setupEvents(deps2) {
         iteration: e.iteration,
         ts: e.ts,
         toolName: e.toolName,
+        ...typeof timeline.toolOk === "boolean" ? { toolOk: timeline.toolOk } : {},
         costUsd: e.costUsd
       })
     });
@@ -6618,9 +7678,9 @@ function setupEvents(deps2) {
     if (wpaths?.projectStatus) {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
-        const dir = path12.dirname(statusFile);
-        await fs10.mkdir(dir, { recursive: true });
-        await fs10.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
+        const dir = path14.dirname(statusFile);
+        await fs11.mkdir(dir, { recursive: true });
+        await fs11.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
       } catch (err) {
         console.error(
           JSON.stringify({
@@ -6634,7 +7694,7 @@ function setupEvents(deps2) {
     }
   });
   if (wpaths?.projectStatus && wpaths.configDir) {
-    const projectsDir = path12.join(wpaths.configDir, "projects");
+    const projectsDir = path14.join(wpaths.configDir, "projects");
     const knownProjectHashes = /* @__PURE__ */ new Set();
     const debounceTimers = /* @__PURE__ */ new Map();
     const DEBOUNCE_MS = 150;
@@ -6698,26 +7758,32 @@ function setupEvents(deps2) {
     let watcher;
     const startWatcher = async () => {
       try {
-        await fs10.mkdir(projectsDir, { recursive: true });
+        await fs11.mkdir(projectsDir, { recursive: true });
         if (disposed) return;
-        watcher = fsWatch(projectsDir, { persistent: true, recursive: true }, async (eventType, filename) => {
-          if (eventType !== "change" && eventType !== "rename") return;
-          if (filename == null) return;
-          const projectHash = statusProjectHashFromWatchFilename(projectsDir, filename);
-          if (!projectHash) return;
-          if (watcherMetrics) watcherMetrics.fileChangesDetected++;
-          if (!knownProjectHashes.has(projectHash)) return;
-          if (watcherMetrics) watcherMetrics.filesProcessed++;
-          try {
-            const targetFile = path12.join(projectsDir, projectHash, "status.json");
-            const content = await fs10.readFile(targetFile, "utf-8");
-            const statusData = JSON.parse(content);
-            scheduleBroadcast(projectHash, statusData);
-          } catch {
+        watcher = fsWatch(
+          projectsDir,
+          { persistent: true, recursive: true },
+          async (eventType, filename) => {
+            if (eventType !== "change" && eventType !== "rename") return;
+            if (filename == null) return;
+            const projectHash = statusProjectHashFromWatchFilename(projectsDir, filename);
+            if (!projectHash) return;
+            if (watcherMetrics) watcherMetrics.fileChangesDetected++;
+            if (!knownProjectHashes.has(projectHash)) return;
+            if (watcherMetrics) watcherMetrics.filesProcessed++;
+            try {
+              const targetFile = path14.join(projectsDir, projectHash, "status.json");
+              const content = await fs11.readFile(targetFile, "utf-8");
+              const statusData = JSON.parse(content);
+              scheduleBroadcast(projectHash, statusData);
+            } catch {
+            }
           }
-        });
+        );
         if (logWatcherMetricsEnabled) {
-          console.log(`[setup-events] Watching ${projectsDir} for status.json changes (hash-filtered, debounced)`);
+          console.log(
+            `[setup-events] Watching ${projectsDir} for status.json changes (hash-filtered, debounced)`
+          );
         }
       } catch (err) {
         console.error(
@@ -6762,17 +7828,19 @@ function setupEvents(deps2) {
       }
     });
   }
-  const globalRoot = globalConfigPath ? path12.dirname(globalConfigPath) : void 0;
+  const globalRoot = globalConfigPath ? path14.dirname(globalConfigPath) : void 0;
   if (globalRoot) {
     const broadcastSessions = async () => {
       try {
         const { SessionRegistry } = await import("@wrongstack/core");
         const registry = new SessionRegistry(globalRoot);
         const sessions = await registry.list();
-        const mySlug = sessions.find((s) => s.pid === process.pid)?.projectSlug;
-        const live = sessions.filter(
-          (s) => s.status === "active" || s.status === "idle"
-        ).filter((s) => mySlug ? s.projectSlug === mySlug : true).map((s) => ({
+        const ownEntry = sessions.find((s) => s.pid === process.pid);
+        const mySlug = ownEntry?.projectSlug ?? wpaths?.projectSlug;
+        const myRoot = path14.resolve(context.projectRoot);
+        const live = sessions.filter((s) => s.status === "active" || s.status === "idle").filter(
+          (s) => mySlug ? s.projectSlug === mySlug : path14.resolve(s.projectRoot) === myRoot
+        ).map((s) => ({
           sessionId: s.sessionId,
           projectName: s.projectName,
           projectSlug: s.projectSlug,
@@ -6784,12 +7852,15 @@ function setupEvents(deps2) {
           status: s.status,
           pid: s.pid,
           startedAt: s.startedAt,
+          lastHeartbeatAt: s.lastHeartbeatAt,
           agentCount: s.agentCount,
           agents: (s.agents ?? []).map((a) => ({
             id: a.id,
             name: a.name,
             status: a.status,
             currentTool: a.currentTool,
+            currentTask: a.currentTask,
+            taskId: a.taskId,
             iterations: a.iterations,
             toolCalls: a.toolCalls,
             costUsd: a.costUsd,
@@ -6798,6 +7869,12 @@ function setupEvents(deps2) {
             ctxPct: a.ctxPct,
             model: a.model,
             partialText: a.partialText,
+            recentTools: a.recentTools,
+            recentMail: a.recentMail,
+            todos: a.todos,
+            latestPrompt: a.latestPrompt,
+            latestPromptAt: a.latestPromptAt,
+            activity: a.activity,
             lastActivityAt: a.lastActivityAt
           }))
         }));
@@ -7023,7 +8100,7 @@ function createSessionStartPayload(g) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path13.basename(projectRoot) || projectRoot,
+      projectName: path15.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: g.getWorkingDir(),
       mode: g.getModeId(),
@@ -7121,13 +8198,13 @@ function armEvents(wssPrimary, wssSecondary, wsHost, wsPort, setupInput, watcher
   };
 }
 function resolveWebuiDistDir(fromUrl, explicitDistDir) {
-  if (explicitDistDir) return path13.resolve(explicitDistDir);
+  if (explicitDistDir) return path15.resolve(explicitDistDir);
   try {
     const requireFromHere2 = createRequire(fromUrl);
     const serverEntry = requireFromHere2.resolve("@wrongstack/webui");
-    return path13.dirname(serverEntry);
+    return path15.dirname(serverEntry);
   } catch {
-    return path13.resolve(path13.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
+    return path15.resolve(path15.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
   }
 }
 function startHttpServer(opts) {
@@ -7140,15 +8217,18 @@ function startHttpServer(opts) {
     apiToken: opts.wsToken,
     requireToken: opts.requireToken,
     watcherMetrics: opts.watcherMetrics,
-    onFleetPing: opts.onFleetPing
+    onFleetPing: opts.onFleetPing,
+    onTechStackEvent: opts.onTechStackEvent,
+    getLlm: opts.getLlm,
+    projectRoot: opts.projectRoot
   });
-  const registryBaseDir = path13.dirname(opts.globalConfigPath);
+  const registryBaseDir = path15.dirname(opts.globalConfigPath);
   httpServer.listen(opts.httpPort, opts.wsHost, () => {
     const openUrl = buildWebUIAccessUrl({ host: opts.wsHost, port: opts.httpPort, token: opts.wsToken, publicUrl: opts.publicUrl });
     console.log(`[WebUI] HTTP server running on ${openUrl}`);
     if (opts.openBrowser) openBrowser(openUrl);
     void registerInstance(
-      { pid: process.pid, surface: "webui", httpPort: opts.httpPort, wsPort: opts.wsPort, host: opts.wsHost, projectRoot: opts.projectRoot, projectName: path13.basename(opts.projectRoot) || opts.projectRoot, startedAt: (/* @__PURE__ */ new Date()).toISOString(), url: buildWebUIAccessUrl({ host: opts.wsHost, port: opts.httpPort, publicUrl: opts.publicUrl }) },
+      { pid: process.pid, surface: "webui", httpPort: opts.httpPort, wsPort: opts.wsPort, host: opts.wsHost, projectRoot: opts.projectRoot, projectName: path15.basename(opts.projectRoot) || opts.projectRoot, startedAt: (/* @__PURE__ */ new Date()).toISOString(), url: buildWebUIAccessUrl({ host: opts.wsHost, port: opts.httpPort, publicUrl: opts.publicUrl }) },
       registryBaseDir
     ).catch((err) => console.warn(JSON.stringify({ level: "warn", event: "webui.instance_record_failed", message: errMessage(err), timestamp: (/* @__PURE__ */ new Date()).toISOString() })));
   });
@@ -7164,7 +8244,7 @@ function registerShutdown(deps2) {
 }
 
 // src/server/pre-context-services.ts
-import * as path16 from "node:path";
+import * as path18 from "node:path";
 import { createRequire as createRequire2 } from "node:module";
 import { DefaultTokenCounter } from "@wrongstack/core/infrastructure";
 import {
@@ -7310,6 +8390,7 @@ function resolveSetupProvider(opts) {
 }
 
 // src/server/context-meta.ts
+import { FallbackProfileManager } from "@wrongstack/core";
 function seedContextMeta(config, context) {
   const meta = context.meta;
   const autonomyCfg = config.autonomy ?? {};
@@ -7329,6 +8410,7 @@ function seedContextMeta(config, context) {
   meta["fallbackProfiles"] = config.fallbackProfiles ?? {};
   meta["favoriteModels"] = config.favoriteModels ?? [];
   meta["favoriteModelsOnly"] = config.favoriteModelsOnly === true;
+  meta["modelAvailabilitySchedule"] = config.modelAvailabilitySchedule ?? [];
   meta["modelMatrix"] = config.modelMatrix ?? {};
   meta["fallbackAuto"] = config.fallbackAuto !== false;
   if (typeof config.uiLocale === "string" && config.uiLocale) meta["uiLocale"] = config.uiLocale;
@@ -7363,6 +8445,7 @@ function seedContextMeta(config, context) {
   meta["thinkingWord"] = autonomyCfg["thinkingWord"] ?? "thinking";
   meta["statuslineMode"] = autonomyCfg["statuslineMode"] ?? "detailed";
   meta["animationStyle"] = autonomyCfg["animationStyle"] ?? "rainbow";
+  meta["showModelReasoning"] = autonomyCfg["showModelReasoning"] !== false;
   meta["breakerEnabled"] = config.circuitBreaker?.enabled === true;
   meta["breakerAutoKillResetMs"] = config.circuitBreaker?.autoKillResetMs ?? 6e4;
   {
@@ -7383,11 +8466,40 @@ function seedContextMeta(config, context) {
   meta["tgDelegate"] = tgExt?.["notifyOnDelegate"] !== false;
   const tgMs = tgExt?.["longToolThresholdMs"];
   meta["tgLongToolMs"] = typeof tgMs === "number" ? tgMs : 3e4;
+  const chimeraExt = config.extensions?.["wstack-chimera"];
+  meta["chimeraEnabled"] = chimeraExt?.["enabled"] !== false;
+  meta["chimeraProvider"] = chimeraExt?.["provider"] ?? "";
+  meta["chimeraModel"] = chimeraExt?.["model"] ?? "";
+  meta["chimeraMaxFiles"] = typeof chimeraExt?.["maxFiles"] === "number" && chimeraExt["maxFiles"] >= 1 ? chimeraExt["maxFiles"] : 15;
+  const autoFix = chimeraExt?.["autoFix"];
+  meta["chimeraAutoFix"] = autoFix === "off" || autoFix === "ask" || autoFix === "auto" ? autoFix : "off";
+  const autoReviewExt = config.extensions?.["wstack-auto-review"];
+  meta["autoReviewEnabled"] = autoReviewExt?.["enabled"] === true;
+  meta["autoReviewProvider"] = autoReviewExt?.["provider"] ?? "";
+  meta["autoReviewModel"] = autoReviewExt?.["model"] ?? "";
+  meta["autoReviewFallbackProfile"] = autoReviewExt?.["fallbackProfile"] ?? "";
+  meta["autoReviewFallbackModels"] = Array.isArray(autoReviewExt?.["fallbackModels"]) ? autoReviewExt?.["fallbackModels"] : [];
+  meta["autoReviewDebounceMs"] = typeof autoReviewExt?.["debounceMs"] === "number" && autoReviewExt["debounceMs"] >= 0 ? autoReviewExt["debounceMs"] : 5e3;
+  meta["autoReviewMaxFilesPerBatch"] = typeof autoReviewExt?.["maxFilesPerBatch"] === "number" && autoReviewExt["maxFilesPerBatch"] >= 1 ? autoReviewExt["maxFilesPerBatch"] : 15;
+  meta["autoReviewMaxConcurrentReviews"] = typeof autoReviewExt?.["maxConcurrentReviews"] === "number" && autoReviewExt["maxConcurrentReviews"] >= 1 ? autoReviewExt["maxConcurrentReviews"] : 2;
+  const cascade = autoReviewExt?.["cascadeOn"];
+  meta["autoReviewCascadeOn"] = cascade === "critical" || cascade === "high" ? cascade : "off";
+  {
+    let resolvedChain = [];
+    try {
+      const mgr = new FallbackProfileManager(config);
+      const named = autoReviewExt?.["fallbackProfile"];
+      resolvedChain = typeof named === "string" && named.length > 0 ? mgr.resolve(named) : mgr.resolveEffective({ fallbackAuto: true });
+    } catch {
+      resolvedChain = [];
+    }
+    meta["autoReviewFallbackModels"] = resolvedChain.map((e) => `${e.providerId}/${e.model}`);
+  }
 }
 
 // src/server/model-auto-discovery.ts
-import * as fs11 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as fs12 from "node:fs/promises";
+import * as path16 from "node:path";
 import { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from "@wrongstack/providers";
 function isOverlayRegistry(value) {
   return !!value && typeof value === "object" && typeof value.mergeOverlay === "function";
@@ -7413,7 +8525,7 @@ function eligibleProviders(config) {
 }
 async function readCache(file) {
   try {
-    return JSON.parse(await fs11.readFile(file, "utf8"));
+    return JSON.parse(await fs12.readFile(file, "utf8"));
   } catch {
     return {};
   }
@@ -7423,7 +8535,7 @@ async function discoverAndMergeWebuiProviders(opts) {
   if (!isOverlayRegistry(registry)) return;
   const targets = eligibleProviders(opts.config);
   if (targets.length === 0) return;
-  const cacheFile = path14.join(opts.cacheDir, "discovered-models-cache.json");
+  const cacheFile = path16.join(opts.cacheDir, "discovered-models-cache.json");
   const cache = await readCache(cacheFile);
   let cacheDirty = false;
   await Promise.all(
@@ -7460,8 +8572,8 @@ async function discoverAndMergeWebuiProviders(opts) {
   );
   if (cacheDirty) {
     try {
-      await fs11.mkdir(path14.dirname(cacheFile), { recursive: true });
-      await fs11.writeFile(cacheFile, JSON.stringify(cache), "utf8");
+      await fs12.mkdir(path16.dirname(cacheFile), { recursive: true });
+      await fs12.writeFile(cacheFile, JSON.stringify(cache), "utf8");
     } catch {
       opts.logger?.debug?.("provider auto-discovery cache write failed");
     }
@@ -7469,7 +8581,7 @@ async function discoverAndMergeWebuiProviders(opts) {
 }
 
 // src/server/standalone-session-identity.ts
-import * as path15 from "node:path";
+import * as path17 from "node:path";
 import {
   AgentStatusTracker,
   FleetNotifier,
@@ -7500,7 +8612,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
         sessionId,
         projectSlug: paths.projectSlug,
         projectRoot: paths.projectRoot,
-        projectName: path15.basename(paths.projectRoot),
+        projectName: path17.basename(paths.projectRoot),
         workingDir: opts.workingDir,
         clientType: "webui",
         pid: process.pid,
@@ -7509,7 +8621,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
       });
       fleetNotifier.notify();
     } catch (err) {
-      logger.debug?.(`WebUI session registry update failed: ${errorMessage2(err)}`);
+      logger.debug?.(`WebUI session registry update failed: ${errorMessage3(err)}`);
     }
   };
   await register(activeSessionId);
@@ -7535,7 +8647,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
       const publisher = core.createHqPublisherFromEnv({
         clientKind: "webui",
         projectRoot: paths.projectRoot,
-        projectName: path15.basename(paths.projectRoot),
+        projectName: path17.basename(paths.projectRoot),
         appConfig: opts.config,
         socketFactory: (url) => new WebSocket2(url)
       });
@@ -7557,7 +8669,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
               events,
               sessionId,
               projectRoot: paths.projectRoot,
-              projectName: path15.basename(paths.projectRoot),
+              projectName: path17.basename(paths.projectRoot),
               globalRoot: paths.globalRoot,
               initialAgents: statusTracker.getAgents(),
               startedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -7594,7 +8706,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
         restartHqBridges(activeSessionId);
       }
     } catch (err) {
-      logger.debug?.(`WebUI HQ telemetry unavailable: ${errorMessage2(err)}`);
+      logger.debug?.(`WebUI HQ telemetry unavailable: ${errorMessage3(err)}`);
     }
   }
   const repointRecovery = async (sessionId) => {
@@ -7617,7 +8729,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
       try {
         restartHqBridges(sessionId);
       } catch (err) {
-        logger.debug?.(`WebUI HQ session swap failed: ${errorMessage2(err)}`);
+        logger.debug?.(`WebUI HQ session swap failed: ${errorMessage3(err)}`);
       }
     });
     await transition;
@@ -7642,7 +8754,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
   };
   return { statusTracker, activate, stop };
 }
-function errorMessage2(err) {
+function errorMessage3(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
@@ -7668,7 +8780,7 @@ async function createPreContextServices(input) {
     await discoverAndMergeWebuiProviders({
       config,
       registry: modelsRegistry,
-      cacheDir: path16.dirname(wpaths.modelsCache),
+      cacheDir: path18.dirname(wpaths.modelsCache),
       logger
     });
   } catch (err) {
@@ -7713,7 +8825,7 @@ async function createPreContextServices(input) {
   configureChildEnvGitIdentity(config.git?.identity ?? null);
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const mcpTokenStore = new MCPVaultTokenStore(
-    path16.join(wpaths.projectDir, "mcp-auth.json"),
+    path18.join(wpaths.projectDir, "mcp-auth.json"),
     vault
   );
   const mcpAuthorizationManager = new MCPAuthorizationManager({ store: mcpTokenStore });
@@ -7808,7 +8920,7 @@ async function createPreContextServices(input) {
   const modelCapabilitiesRef = { current: modelCapabilities };
   const skillLoader = config.features.skills ? new DefaultSkillLoader({ paths: wpaths }) : void 0;
   const skillInstaller = config.features.skills ? new SkillInstaller({
-    manifestPath: path16.join(wpaths.globalRoot, "installed-skills.json"),
+    manifestPath: path18.join(wpaths.globalRoot, "installed-skills.json"),
     projectSkillsDir: wpaths.inProjectSkills,
     globalSkillsDir: wpaths.globalSkills,
     projectHash: wpaths.projectHash,
@@ -7818,7 +8930,7 @@ async function createPreContextServices(input) {
   const bundledPromptsDir = promptsEnabled ? (() => {
     try {
       const req = createRequire2(import.meta.url);
-      return path16.join(path16.dirname(req.resolve("@wrongstack/core/package.json")), "data", "prompts");
+      return path18.join(path18.dirname(req.resolve("@wrongstack/core/package.json")), "data", "prompts");
     } catch {
       return void 0;
     }
@@ -7919,7 +9031,7 @@ function isSuperMemoryService(memoryStore) {
 }
 
 // src/server/start-webui.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import {
   createDefaultPipelines,
   createSessionEventBridge,
@@ -7949,7 +9061,7 @@ function patchConfig(config, updates) {
 }
 
 // src/server/backend-services.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import {
   Agent,
   AutoCompactionMiddleware as AutoCompactionMiddlewareCtor,
@@ -7975,7 +9087,7 @@ import {
 } from "@wrongstack/core";
 
 // src/server/collaboration-ws-handler.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
 var REPLAY_LIMIT = 50;
 var PAUSE_TIMEOUT_MS = 6e4;
@@ -8107,7 +9219,7 @@ var CollaborationWebSocketHandler = class {
       return;
     }
     const participant = {
-      participantId: randomUUID(),
+      participantId: randomUUID2(),
       ws,
       sessionId,
       role,
@@ -8727,8 +9839,8 @@ var CollaborationWebSocketHandler = class {
 };
 
 // src/server/codebase-indexing.ts
-import * as fs12 from "node:fs";
-import * as path17 from "node:path";
+import * as fs13 from "node:fs";
+import * as path19 from "node:path";
 import {
   cancelPendingReindexes,
   enqueueReindex,
@@ -8748,17 +9860,15 @@ var IGNORE_DIRS = /* @__PURE__ */ new Set([
   ".nyc_output"
 ]);
 function setupWebUICodebaseIndexing(deps2) {
-  const indexing = deps2.config.indexing;
-  if (!indexing) return noopIndexing();
-  const idx = indexing;
+  const idx = deps2.config.indexing;
   const indexDir = typeof deps2.context.meta["codebaseIndexDir"] === "string" ? deps2.context.meta["codebaseIndexDir"] : void 0;
-  const debounceMs = idx.debounceMs ?? 400;
+  const debounceMs = idx?.debounceMs ?? 400;
   const onError = (err) => {
     deps2.logger.debug(
       `webui codebase auto-index failed: ${err instanceof Error ? err.message : String(err)}`
     );
   };
-  if (idx.onSessionStart) {
+  if (idx?.onSessionStart) {
     void runStartupIndex({
       projectRoot: deps2.projectRoot,
       indexDir,
@@ -8775,14 +9885,27 @@ function setupWebUICodebaseIndexing(deps2) {
     });
   }
   let watcher;
-  if (idx.watchExternal) {
+  const lastWatcherEvent = /* @__PURE__ */ new Map();
+  if (idx?.watchExternal || deps2.events) {
     try {
-      watcher = fs12.watch(deps2.projectRoot, { recursive: true }, (_event, filename) => {
+      watcher = fs13.watch(deps2.projectRoot, { recursive: true }, (eventType, filename) => {
         if (!filename) return;
         const rel = filename.toString();
         if (isIgnored(rel)) return;
-        const abs = path17.resolve(deps2.projectRoot, rel);
-        enqueueFile(abs);
+        const abs = path19.resolve(deps2.projectRoot, rel);
+        if (!isInside2(deps2.projectRoot, abs) || !isIndexableFile(abs)) return;
+        const now = Date.now();
+        if (now - (lastWatcherEvent.get(abs) ?? 0) > 75) {
+          lastWatcherEvent.set(abs, now);
+          deps2.events?.emit("file.activity", {
+            filePath: path19.normalize(abs),
+            operation: eventType === "rename" && !fs13.existsSync(abs) ? "delete" : "edit",
+            phase: "changed",
+            source: "watcher",
+            at: now
+          });
+        }
+        if (idx?.watchExternal) enqueueFile(abs);
       });
       watcher.on("error", (err) => deps2.logger.debug(`webui codebase index watcher error: ${err}`));
       watcher.unref?.();
@@ -8793,8 +9916,8 @@ function setupWebUICodebaseIndexing(deps2) {
     }
   }
   function enqueueFile(filePath) {
-    if (!idx.onEdit && !idx.watchExternal) return;
-    const abs = path17.isAbsolute(filePath) ? path17.normalize(filePath) : path17.resolve(deps2.projectRoot, filePath);
+    if (!idx || !idx.onEdit && !idx.watchExternal) return;
+    const abs = path19.isAbsolute(filePath) ? path19.normalize(filePath) : path19.resolve(deps2.projectRoot, filePath);
     if (!isInside2(deps2.projectRoot, abs) || !isIndexableFile(abs)) return;
     enqueueReindex({
       projectRoot: deps2.projectRoot,
@@ -8807,23 +9930,28 @@ function setupWebUICodebaseIndexing(deps2) {
   }
   return {
     onFileWritten(filePath) {
-      if (idx.onEdit) enqueueFile(filePath);
+      const abs = path19.isAbsolute(filePath) ? path19.normalize(filePath) : path19.resolve(deps2.projectRoot, filePath);
+      deps2.events?.emit("file.activity", {
+        filePath: abs,
+        operation: "write",
+        phase: "completed",
+        source: "editor",
+        at: Date.now(),
+        sessionId: deps2.context.session?.id,
+        agentId: "webui-editor",
+        agentName: "WebUI Editor"
+      });
+      if (idx?.onEdit) enqueueFile(abs);
     },
     dispose() {
       try {
         watcher?.close();
       } catch {
       }
-      cancelPendingReindexes();
-      shutdownCodebaseIndexHost();
-    }
-  };
-}
-function noopIndexing() {
-  return {
-    onFileWritten() {
-    },
-    dispose() {
+      if (idx) {
+        cancelPendingReindexes();
+        void shutdownCodebaseIndexHost();
+      }
     }
   };
 }
@@ -8831,16 +9959,16 @@ function isIgnored(rel) {
   return rel.split(/[/\\]/).some((seg) => IGNORE_DIRS.has(seg));
 }
 function isInside2(root, target) {
-  const normalizedRoot = path17.resolve(root);
-  const normalizedTarget = path17.resolve(target);
-  return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(normalizedRoot + path17.sep);
+  const normalizedRoot = path19.resolve(root);
+  const normalizedTarget = path19.resolve(target);
+  return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(normalizedRoot + path19.sep);
 }
 
 // src/server/discover-mailbox-bridge.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createRequire as createRequire3 } from "node:module";
-import { existsSync } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { dirname as dirname9, join as join13 } from "node:path";
 import { resolveProjectDir, wstackGlobalRoot as wstackGlobalRoot2 } from "@wrongstack/core";
 import { readLiveLock } from "@wrongstack/core/coordination";
 var MAILBOX_BRIDGE_BOOT_TIMEOUT_MS = 5e3;
@@ -8968,16 +10096,16 @@ function mailboxServeInvocation(projectRoot) {
 function findWorkspaceCliEntry(projectRoot) {
   let dir = projectRoot;
   for (let i = 0; i < 6; i++) {
-    const candidate = join12(dir, "packages", "cli", "dist", "index.js");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname8(dir);
+    const candidate = join13(dir, "packages", "cli", "dist", "index.js");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname9(dir);
     if (parent === dir) return null;
     dir = parent;
   }
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve12) => setTimeout(resolve12, ms));
 }
 
 // src/server/terminal-ws-handler.ts
@@ -8989,6 +10117,9 @@ var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
 var requireFromHere = createRequire4(import.meta.url);
 var cachedNodePty;
+function resolveTerminalShell(platform = process.platform, env = process.env) {
+  return platform === "win32" ? env.COMSPEC || "cmd.exe" : env.SHELL || "/bin/sh";
+}
 var TerminalWebSocketHandler = class {
   constructor(getCwd, logger, loadNodePty = defaultLoadNodePty, killProcessTree = defaultKillProcessTree) {
     this.getCwd = getCwd;
@@ -9044,7 +10175,7 @@ var TerminalWebSocketHandler = class {
       });
       return;
     }
-    const shell = process.platform === "win32" ? process.env.COMSPEC || "cmd.exe" : process.env.SHELL || "/bin/bash";
+    const shell = resolveTerminalShell();
     const nodePty = this.loadNodePty();
     if (!nodePty) {
       const msg = "Integrated terminal unavailable: optional dependency node-pty is not installed. Install node-pty to enable WebUI terminal sessions.";
@@ -9232,7 +10363,8 @@ async function createAgentServices(input) {
     config,
     context,
     projectRoot,
-    logger
+    logger,
+    events
   });
   const compactor = createStrategyCompactor({
     strategy: config.context?.strategy,
@@ -9363,13 +10495,17 @@ async function createAgentServices(input) {
     toolExecutor
   });
   if (config.features.memory && config.features.memoryConsolidation !== false) {
-    agent.extensions.register(new SessionMemoryConsolidator({ memoryStore }));
+    const consSuperMemory = typeof memoryStore["rememberSuper"] === "function" ? memoryStore : void 0;
+    agent.extensions.register(new SessionMemoryConsolidator({
+      memoryStore,
+      ...consSuperMemory ? { superMemory: consSuperMemory } : {}
+    }));
   }
   console.log("[WebUI] Agent initialized");
   const brainCfg = resolveBrainConfigDefaults(config.brain, {
     fallbackModels: config.fallbackModels
   });
-  const brainLedgerPath = join13(wpaths.projectDir, "brain-ledger.jsonl");
+  const brainLedgerPath = join14(wpaths.projectDir, "brain-ledger.jsonl");
   let brainLedgerEnabled = brainCfg.ledger?.enabled !== false;
   let brainLedger;
   const startBrainLedger = () => {
@@ -9479,7 +10615,7 @@ async function createAgentServices(input) {
   });
   brainMonitor.start();
   console.log("[WebUI] Brain initialized (tiered policy \u2192 LLM, monitor active)");
-  const autoPhaseHandler = new AutoPhaseWebSocketHandler(
+  const goalHandler = new GoalWebSocketHandler(
     agent,
     context,
     logger,
@@ -9551,7 +10687,7 @@ async function createAgentServices(input) {
       return brainLedger;
     },
     codebaseIndexing,
-    autoPhaseHandler,
+    goalHandler,
     specsHandler,
     sddBoardHandler,
     sddWizardHandler,
@@ -9569,6 +10705,7 @@ function isSuperMemoryRetriever(memoryStore) {
 // src/server/pending-confirms.ts
 function resolveYoloEligiblePendingConfirms(pendingConfirms) {
   for (const [id, confirm] of pendingConfirms) {
+    if (confirm.boundaryReason) continue;
     pendingConfirms.delete(id);
     confirm.resolve("yes");
   }
@@ -9624,6 +10761,9 @@ function createConnectionHandler(opts) {
     }
     void opts.sessionStartPayload().then(async (payload) => {
       const enriched = { ...payload };
+      if (typeof opts.context.lastRequestTokens === "number" && opts.context.lastRequestTokens > 0) {
+        enriched.lastInputTokens = opts.context.lastRequestTokens;
+      }
       try {
         const replay = await opts.loadReplay?.();
         const live = replay?.messages ?? opts.context.messages ?? [];
@@ -9653,7 +10793,7 @@ function createConnectionHandler(opts) {
         })
       );
     });
-    opts.autoPhaseHandler.addClient(ws);
+    opts.goalHandler.addClient(ws);
     opts.specsHandler.addClient(ws);
     opts.sddBoardHandler.addClient(ws);
     opts.sddWizardHandler.addClient(ws);
@@ -9671,8 +10811,21 @@ function createConnectionHandler(opts) {
         });
         return;
       }
+      let rawObj;
+      try {
+        rawObj = JSON.parse(data.toString());
+      } catch (err) {
+        console.error(
+          JSON.stringify({
+            level: "error",
+            event: "webui.ws_message_parse_failed",
+            message: err instanceof Error ? err.message : String(err),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        return;
+      }
       try {
-        const rawObj = JSON.parse(data.toString());
         if (typeof rawObj === "object" && rawObj !== null) {
           const obj = rawObj;
           if (Object.hasOwn(obj, "__proto__") || Object.hasOwn(obj, "constructor") || Object.hasOwn(obj, "prototype")) {
@@ -9690,7 +10843,7 @@ function createConnectionHandler(opts) {
         console.error(
           JSON.stringify({
             level: "error",
-            event: "webui.ws_message_parse_failed",
+            event: "webui.ws_message_handler_failed",
             message: err instanceof Error ? err.message : String(err),
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           })
@@ -9725,7 +10878,12 @@ function createConnectionHandler(opts) {
 }
 
 // src/server/message-dispatcher.ts
-import path18 from "node:path";
+import path20 from "node:path";
+import {
+  ChronicleQueryEngine,
+  resolveWstackPaths as resolveWstackPaths2
+} from "@wrongstack/core";
+import * as os2 from "node:os";
 import {
   buildUserContentBlocks,
   IncomingImageError,
@@ -9738,9 +10896,9 @@ import {
   VisionUrlBlockedError
 } from "@wrongstack/runtime/vision";
 
-// src/server/autophase-routes.ts
-async function handleAutoPhaseRoute(_ws, msg, handlers) {
-  if (!msg.type.startsWith("autophase.")) return false;
+// src/server/goal-routes.ts
+async function handleGoalRoute(_ws, msg, handlers) {
+  if (!msg.type.startsWith("goal.")) return false;
   await handlers.handleMessage(msg);
   return true;
 }
@@ -9776,9 +10934,9 @@ async function handleGoalGet(projectRoot, broadcast2) {
     const { readFile: readFile11 } = await import("node:fs/promises");
     const raw = await readFile11(goalPath, "utf8");
     const goal = JSON.parse(raw);
-    broadcast2({ type: "goal.updated", payload: goal });
+    broadcast2({ type: "goal-state.updated", payload: goal });
   } catch {
-    broadcast2({ type: "goal.updated", payload: null });
+    broadcast2({ type: "goal-state.updated", payload: null });
   }
 }
 
@@ -10027,18 +11185,20 @@ import {
   createBoard,
   duplicateBoard,
   exportBoardToTaskGraph,
-  generateBoardFromDescription,
-  getBoard,
+  createBoardFromText,
+  getBoard as getBoard2,
   getKanbanOrchestrationSnapshot,
   getKanbanQueueHealth,
   getTask,
   getTaskChain,
   listBoards,
   listReadyTasks,
+  listTaskActivity,
   mergeTasks,
   moveTask,
   parseLinesIntoTasks,
   reconcileKanbanBoard,
+  recordTaskActivity,
   recoverStaleTaskAssignments,
   releaseTaskClaim,
   removeBoard,
@@ -10047,13 +11207,41 @@ import {
   setTaskChain,
   splitTask,
   syncBoardFromTaskGraph,
+  touchKanbanPresence,
   transferTaskToBoard,
+  transitionTask,
   updateBoard,
   updateCheckOnTask,
   updateGoalMetricOnTask,
   updateTask
 } from "@wrongstack/kanban";
 import { applySessionKanbanTaskToSource } from "@wrongstack/tools/session-kanban";
+function paginateKanbanBoards(boards, input) {
+  const pageSize = Math.min(100, Math.max(1, Math.floor(input.pageSize)));
+  const activeSessionIds = new Set(input.activeSessionIds ?? []);
+  const isActive = (board) => board.presence?.some((entry) => entry.active) === true || board.tags?.some(
+    (tag) => tag.startsWith("session:") && activeSessionIds.has(tag.slice(8))
+  ) === true;
+  const sorted = [...boards].sort((left, right) => {
+    const activityOrder = Number(isActive(right)) - Number(isActive(left));
+    return activityOrder || right.updatedAt.localeCompare(left.updatedAt);
+  });
+  const activeTotal = sorted.filter(isActive).length;
+  const total = sorted.length;
+  const totalPages = Math.max(1, Math.ceil(total / pageSize));
+  const requestedPage = Number.isFinite(input.page) ? Math.floor(input.page) : 1;
+  const page = Math.min(totalPages, Math.max(1, requestedPage));
+  const start = (page - 1) * pageSize;
+  return {
+    items: sorted.slice(start, start + pageSize),
+    total,
+    page,
+    pageSize,
+    totalPages,
+    activeTotal,
+    orphanedTotal: total - activeTotal
+  };
+}
 async function syncSessionSource(ctx, task, remove = false) {
   if (!ctx.context) return;
   const update = await applySessionKanbanTaskToSource(ctx.context, task, { remove });
@@ -10074,22 +11262,62 @@ function fail(ws, type, message) {
 function has(payload, key) {
   return payload !== void 0 && Object.hasOwn(payload, key);
 }
+function activityContext(ctx, actor, note) {
+  const sessionId = ctx.context?.session?.id;
+  return {
+    ...sessionId ? { sessionId } : {},
+    ...actor ? { actor } : {},
+    ...note?.trim() ? { note: note.trim() } : {}
+  };
+}
+async function touchTaskPresence(ctx, boardId, taskId) {
+  const context = ctx.context;
+  const sessionId = context?.session?.id;
+  if (!context || !sessionId) return null;
+  try {
+    return await touchKanbanPresence(ctx.projectRoot, boardId, {
+      sessionId,
+      agentId: context.agentId || "webui",
+      agentName: context.agentName || context.agentId || "WebUI",
+      taskId
+    });
+  } catch {
+    return null;
+  }
+}
 async function handleKanbanRoute(ws, msg, ctx) {
   if (!msg.type.startsWith("kanban.")) return false;
   const payload = msg.payload;
   const type = msg.type;
   try {
     switch (type) {
-      case "kanban.list":
-        ok(ws, type, await listBoards(ctx.projectRoot));
+      case "kanban.list": {
+        const boards = await listBoards(ctx.projectRoot);
+        const requestedPage = Number(payload?.page);
+        const requestedPageSize = Number(payload?.pageSize);
+        if (!Number.isFinite(requestedPage) || !Number.isFinite(requestedPageSize)) {
+          ok(ws, type, boards);
+          return true;
+        }
+        const activeSessionIds = Array.isArray(payload?.activeSessionIds) ? payload.activeSessionIds.filter((id) => typeof id === "string") : [];
+        ok(
+          ws,
+          type,
+          paginateKanbanBoards(boards, {
+            page: requestedPage,
+            pageSize: requestedPageSize,
+            activeSessionIds
+          })
+        );
         return true;
+      }
       case "kanban.get": {
         const boardId = payload?.boardId;
         if (!boardId) {
           fail(ws, type, "boardId required");
           return true;
         }
-        const board = await getBoard(ctx.projectRoot, boardId);
+        const board = await getBoard2(ctx.projectRoot, boardId);
         board ? ok(ws, type, board) : fail(ws, type, `Board not found: ${boardId}`);
         return true;
       }
@@ -10109,7 +11337,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId required");
           return true;
         }
-        const board = await getBoard(ctx.projectRoot, boardId);
+        const board = await getBoard2(ctx.projectRoot, boardId);
         if (!board) {
           fail(ws, type, `Board not found: ${boardId}`);
           return true;
@@ -10147,7 +11375,9 @@ async function handleKanbanRoute(ws, msg, ctx) {
             title,
             ...payload?.description ? { description: payload.description } : {},
             ...payload?.tags ? { tags: payload.tags } : {},
-            ...payload?.columns ? { columns: payload.columns } : {}
+            ...payload?.columns ? { columns: payload.columns } : {},
+            ...has(payload, "lifecycle") ? { lifecycle: payload?.lifecycle } : {},
+            ...has(payload, "boundary") ? { boundary: payload?.boundary } : {}
           })
         );
         return true;
@@ -10163,8 +11393,14 @@ async function handleKanbanRoute(ws, msg, ctx) {
           ...payload?.description ? { description: payload.description } : {},
           ...payload?.tags ? { tags: payload.tags } : {},
           ...payload?.columns ? { columns: payload.columns } : {},
+          ...has(payload, "lifecycle") ? {
+            lifecycle: payload?.lifecycle ?? null
+          } : {},
           ...has(payload, "supervisor") ? {
             supervisor: payload?.supervisor ?? null
+          } : {},
+          ...has(payload, "boundary") ? {
+            boundary: payload?.boundary ?? null
           } : {}
         });
         board ? ok(ws, type, board) : fail(ws, type, `Board not found: ${boardId}`);
@@ -10191,7 +11427,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId required");
           return true;
         }
-        const board = await getBoard(ctx.projectRoot, boardId);
+        const board = await getBoard2(ctx.projectRoot, boardId);
         const activeSessionId = ctx.context?.session?.id;
         if (activeSessionId && board?.tags?.includes(`session:${activeSessionId}`)) {
           fail(ws, type, "The active session Kanban board cannot be deleted.");
@@ -10211,7 +11447,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
         }
         const board = await createBoard(
           ctx.projectRoot,
-          generateBoardFromDescription({
+          createBoardFromText({
             description,
             ...payload?.title ? { title: payload.title } : {},
             ...payload?.context ? { context: payload.context } : {}
@@ -10223,7 +11459,7 @@ async function handleKanbanRoute(ws, msg, ctx) {
         )) {
           await addTask(ctx.projectRoot, board.id, taskInput);
         }
-        ok(ws, type, await getBoard(ctx.projectRoot, board.id) ?? board);
+        ok(ws, type, await getBoard2(ctx.projectRoot, board.id) ?? board);
         return true;
       }
       case "kanban.task.ready": {
@@ -10313,14 +11549,21 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId and title required");
           return true;
         }
-        const result = await addTask(ctx.projectRoot, boardId, {
-          title,
-          columnId: payload?.columnId ?? "backlog",
-          ...payload?.description ? { description: payload.description } : {},
-          ...payload?.priority ? { priority: payload.priority } : {},
-          ...payload?.assignedAgent ? { assignedAgent: payload.assignedAgent } : {},
-          ...payload?.labels ? { labels: payload.labels } : {}
-        });
+        const result = await addTask(
+          ctx.projectRoot,
+          boardId,
+          {
+            title,
+            columnId: payload?.columnId ?? "backlog",
+            ...payload?.description ? { description: payload.description } : {},
+            ...payload?.dueDate ? { dueDate: payload.dueDate } : {},
+            ...payload?.priority ? { priority: payload.priority } : {},
+            ...payload?.assignedAgent ? { assignedAgent: payload.assignedAgent } : {},
+            ...payload?.labels ? { labels: payload.labels } : {},
+            ...has(payload, "boundary") ? { boundary: payload?.boundary } : {}
+          },
+          activityContext(ctx, "webui", payload?.activityNote)
+        );
         result ? ok(ws, type, result.task) : fail(ws, type, `Board not found: ${boardId}`);
         return true;
       }
@@ -10376,25 +11619,35 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId and taskId required");
           return true;
         }
-        const board = await updateTask(ctx.projectRoot, boardId, taskId, {
-          ...has(payload, "title") ? { title: payload?.title } : {},
-          ...has(payload, "description") ? { description: payload?.description ?? "" } : {},
-          ...has(payload, "columnId") ? { columnId: payload?.columnId } : {},
-          ...has(payload, "priority") ? { priority: payload?.priority } : {},
-          ...has(payload, "type") ? { type: payload?.type } : {},
-          ...has(payload, "status") ? { status: payload?.status } : {},
-          ...has(payload, "dependsOn") ? { dependsOn: payload?.dependsOn ?? [] } : {},
-          ...has(payload, "chain") ? { chain: payload?.chain ?? null } : {},
-          ...has(payload, "labels") ? { labels: payload?.labels ?? [] } : {},
-          ...has(payload, "estimatedHours") ? { estimatedHours: Number(payload?.estimatedHours ?? 0) } : {},
-          ...has(payload, "actualHours") ? { actualHours: Number(payload?.actualHours ?? 0) } : {},
-          ...has(payload, "retryPolicy") ? {
-            retryPolicy: payload?.retryPolicy ?? null
-          } : {},
-          ...has(payload, "costCeilingUsd") ? {
-            costCeilingUsd: payload?.costCeilingUsd === null || payload?.costCeilingUsd === "" ? null : Number(payload?.costCeilingUsd)
-          } : {}
-        });
+        const board = await updateTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            ...has(payload, "title") ? { title: payload?.title } : {},
+            ...has(payload, "description") ? { description: payload?.description ?? "" } : {},
+            ...has(payload, "dueDate") ? { dueDate: payload?.dueDate ?? null } : {},
+            ...has(payload, "columnId") ? { columnId: payload?.columnId } : {},
+            ...has(payload, "priority") ? { priority: payload?.priority } : {},
+            ...has(payload, "type") ? { type: payload?.type } : {},
+            ...has(payload, "status") ? { status: payload?.status } : {},
+            ...has(payload, "dependsOn") ? { dependsOn: payload?.dependsOn ?? [] } : {},
+            ...has(payload, "chain") ? { chain: payload?.chain ?? null } : {},
+            ...has(payload, "labels") ? { labels: payload?.labels ?? [] } : {},
+            ...has(payload, "estimatedHours") ? { estimatedHours: Number(payload?.estimatedHours ?? 0) } : {},
+            ...has(payload, "actualHours") ? { actualHours: Number(payload?.actualHours ?? 0) } : {},
+            ...has(payload, "retryPolicy") ? {
+              retryPolicy: payload?.retryPolicy ?? null
+            } : {},
+            ...has(payload, "costCeilingUsd") ? {
+              costCeilingUsd: payload?.costCeilingUsd === null || payload?.costCeilingUsd === "" ? null : Number(payload?.costCeilingUsd)
+            } : {},
+            ...has(payload, "boundary") ? {
+              boundary: payload?.boundary ?? null
+            } : {}
+          },
+          activityContext(ctx, "webui", payload?.activityNote)
+        );
         if (!board) {
           fail(ws, type, "Board or task not found");
           return true;
@@ -10404,6 +11657,32 @@ async function handleKanbanRoute(ws, msg, ctx) {
         ok(ws, type, task);
         return true;
       }
+      case "kanban.task.transition": {
+        const boardId = payload?.boardId;
+        const taskId = payload?.taskId;
+        const to = payload?.to;
+        const actor = payload?.actor;
+        const comment = payload?.comment;
+        if (!boardId || !taskId || !to || !actor || !comment) {
+          fail(ws, type, "boardId, taskId, to, actor, and comment required");
+          return true;
+        }
+        const result = await transitionTask(ctx.projectRoot, boardId, taskId, {
+          to,
+          actor,
+          comment,
+          ...payload?.action ? { action: payload.action } : {},
+          ...payload?.attachment ? { attachment: payload.attachment } : {},
+          ...payload?.patch ? { patch: payload.patch } : {}
+        });
+        if (!result) {
+          fail(ws, type, "Board or task not found");
+          return true;
+        }
+        await syncSessionSource(ctx, result.task);
+        ok(ws, type, result);
+        return true;
+      }
       case "kanban.task.move": {
         const boardId = payload?.boardId;
         const taskId = payload?.taskId;
@@ -10417,7 +11696,8 @@ async function handleKanbanRoute(ws, msg, ctx) {
           boardId,
           taskId,
           columnId,
-          payload?.order
+          payload?.order,
+          activityContext(ctx, "webui", payload?.activityNote)
         );
         if (!board) {
           fail(ws, type, "Move failed");
@@ -10522,14 +11802,24 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId, taskId, and name required");
           return true;
         }
-        const board = await addGoalMetricToTask(ctx.projectRoot, boardId, taskId, {
-          name: name2,
-          ...payload?.status ? { status: payload.status } : {},
-          ...payload?.target !== void 0 ? { target: payload.target } : {},
-          ...payload?.current !== void 0 ? { current: payload.current } : {},
-          ...payload?.unit ? { unit: payload.unit } : {},
-          ...payload?.notes ? { notes: payload.notes } : {}
-        });
+        const board = await addGoalMetricToTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            name: name2,
+            ...payload?.status ? { status: payload.status } : {},
+            ...payload?.target !== void 0 ? { target: payload.target } : {},
+            ...payload?.current !== void 0 ? { current: payload.current } : {},
+            ...payload?.unit ? { unit: payload.unit } : {},
+            ...payload?.notes ? { notes: payload.notes } : {}
+          },
+          activityContext(
+            ctx,
+            "webui",
+            payload?.activityNote ?? `Goal metric added: ${name2}.`
+          )
+        );
         board ? ok(ws, type, board) : fail(ws, type, "Board or task not found");
         return true;
       }
@@ -10541,14 +11831,25 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId, taskId, and metricId required");
           return true;
         }
-        const board = await updateGoalMetricOnTask(ctx.projectRoot, boardId, taskId, metricId, {
-          ...payload?.name ? { name: payload.name } : {},
-          ...payload?.status ? { status: payload.status } : {},
-          ...payload?.target !== void 0 ? { target: payload.target } : {},
-          ...payload?.current !== void 0 ? { current: payload.current } : {},
-          ...payload?.unit ? { unit: payload.unit } : {},
-          ...payload?.notes ? { notes: payload.notes } : {}
-        });
+        const board = await updateGoalMetricOnTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          metricId,
+          {
+            ...payload?.name ? { name: payload.name } : {},
+            ...payload?.status ? { status: payload.status } : {},
+            ...payload?.target !== void 0 ? { target: payload.target } : {},
+            ...payload?.current !== void 0 ? { current: payload.current } : {},
+            ...payload?.unit ? { unit: payload.unit } : {},
+            ...payload?.notes ? { notes: payload.notes } : {}
+          },
+          activityContext(
+            ctx,
+            "webui",
+            payload?.activityNote ?? "Goal metric updated in WebUI."
+          )
+        );
         board ? ok(ws, type, board) : fail(ws, type, "Metric not found");
         return true;
       }
@@ -10559,23 +11860,29 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId and taskId required");
           return true;
         }
-        const board = await assignTask(ctx.projectRoot, boardId, taskId, {
-          ...payload?.agentId ? { agentId: payload.agentId } : {},
-          ...payload?.name ? { name: payload.name } : {},
-          ...payload?.role ? { role: payload.role } : {},
-          ...payload?.provider ? { provider: payload.provider } : {},
-          ...payload?.model ? { model: payload.model } : {},
-          ...payload?.modelRouting ? { modelRouting: payload.modelRouting } : {},
-          ...payload?.fallbackProfile ? { fallbackProfile: payload.fallbackProfile } : {},
-          ...payload?.fallbackModels ? { fallbackModels: payload.fallbackModels } : {},
-          ...payload?.skills ? { skills: payload.skills } : {},
-          ...payload?.tools ? { tools: payload.tools } : {},
-          ...payload?.allowedCapabilities ? { allowedCapabilities: payload.allowedCapabilities } : {},
-          ...payload?.assignee ? { assignee: payload.assignee } : {},
-          ...payload?.maxAttempts !== void 0 ? { maxAttempts: Number(payload.maxAttempts) } : {},
-          ...payload?.costCeilingUsd !== void 0 ? { costCeilingUsd: Number(payload.costCeilingUsd) } : {},
-          ...payload?.retryPolicy ? { retryPolicy: payload.retryPolicy } : {}
-        });
+        const board = await assignTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            ...payload?.agentId ? { agentId: payload.agentId } : {},
+            ...payload?.name ? { name: payload.name } : {},
+            ...payload?.role ? { role: payload.role } : {},
+            ...payload?.provider ? { provider: payload.provider } : {},
+            ...payload?.model ? { model: payload.model } : {},
+            ...payload?.modelRouting ? { modelRouting: payload.modelRouting } : {},
+            ...payload?.fallbackProfile ? { fallbackProfile: payload.fallbackProfile } : {},
+            ...payload?.fallbackModels ? { fallbackModels: payload.fallbackModels } : {},
+            ...payload?.skills ? { skills: payload.skills } : {},
+            ...payload?.tools ? { tools: payload.tools } : {},
+            ...payload?.allowedCapabilities ? { allowedCapabilities: payload.allowedCapabilities } : {},
+            ...payload?.assignee ? { assignee: payload.assignee } : {},
+            ...payload?.maxAttempts !== void 0 ? { maxAttempts: Number(payload.maxAttempts) } : {},
+            ...payload?.costCeilingUsd !== void 0 ? { costCeilingUsd: Number(payload.costCeilingUsd) } : {},
+            ...payload?.retryPolicy ? { retryPolicy: payload.retryPolicy } : {}
+          },
+          activityContext(ctx, void 0, payload?.activityNote)
+        );
         board ? ok(ws, type, findTask(board.tasks, taskId)) : fail(ws, type, "Board or task not found");
         return true;
       }
@@ -10587,11 +11894,21 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId, taskId, and description required");
           return true;
         }
-        const board = await addCheckToTask(ctx.projectRoot, boardId, taskId, {
-          description,
-          type: payload?.checkType ?? "manual",
-          status: payload?.status ?? "pending"
-        });
+        const board = await addCheckToTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            description,
+            type: payload?.checkType ?? "manual",
+            status: payload?.status ?? "pending"
+          },
+          activityContext(
+            ctx,
+            "webui",
+            payload?.activityNote ?? `Acceptance check added: ${description}.`
+          )
+        );
         board ? ok(ws, type, board) : fail(ws, type, "Board or task not found");
         return true;
       }
@@ -10603,9 +11920,20 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId, taskId, and checkId required");
           return true;
         }
-        const board = await updateCheckOnTask(ctx.projectRoot, boardId, taskId, checkId, {
-          ...has(payload, "status") ? { status: payload?.status } : {}
-        });
+        const board = await updateCheckOnTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          checkId,
+          {
+            ...has(payload, "status") ? { status: payload?.status } : {}
+          },
+          activityContext(
+            ctx,
+            "webui",
+            payload?.activityNote ?? `Acceptance check updated${payload?.status ? ` to ${String(payload.status)}` : ""}.`
+          )
+        );
         if (!board) fail(ws, type, "Check not found");
         else ok(ws, type, (await reconcileKanbanBoard(ctx.projectRoot, boardId))?.board ?? board);
         return true;
@@ -10618,10 +11946,17 @@ async function handleKanbanRoute(ws, msg, ctx) {
           fail(ws, type, "boardId, taskId, and content required");
           return true;
         }
-        const board = await addNoteToTask(ctx.projectRoot, boardId, taskId, {
-          author: payload?.author ?? "webui",
-          content
-        });
+        const author = payload?.author ?? "webui";
+        const board = await addNoteToTask(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            author,
+            content
+          },
+          activityContext(ctx, author)
+        );
         board ? ok(ws, type, board) : fail(ws, type, "Board or task not found");
         return true;
       }
@@ -10664,7 +11999,62 @@ async function handleKanbanRoute(ws, msg, ctx) {
           return true;
         }
         const task = await getTask(ctx.projectRoot, boardId, taskId);
-        task ? ok(ws, type, task) : fail(ws, type, "Task not found");
+        if (task) {
+          await touchTaskPresence(ctx, boardId, task.id);
+          ok(ws, type, task);
+        } else {
+          fail(ws, type, "Task not found");
+        }
+        return true;
+      }
+      case "kanban.task.activity": {
+        const boardId = payload?.boardId;
+        const taskId = payload?.taskId;
+        if (!boardId || !taskId) {
+          fail(ws, type, "boardId and taskId required");
+          return true;
+        }
+        const presenceBoard = await touchTaskPresence(ctx, boardId, taskId);
+        const events = await listTaskActivity(ctx.projectRoot, boardId, taskId, {
+          ...typeof payload?.limit === "number" ? { limit: payload.limit } : {}
+        });
+        ok(ws, type, {
+          boardId,
+          taskId,
+          events,
+          presence: presenceBoard?.presence?.filter((entry) => entry.taskId === taskId) ?? []
+        });
+        return true;
+      }
+      case "kanban.task.activity.add": {
+        const boardId = payload?.boardId;
+        const taskId = payload?.taskId;
+        const kind = payload?.kind;
+        const summary = payload?.summary;
+        const allowedKinds = ["decision", "attempt", "result", "blocker", "observation"];
+        const allowedOutcomes = ["succeeded", "failed", "partial", "skipped", "unknown"];
+        if (!boardId || !taskId || !summary?.trim() || !allowedKinds.includes(kind)) {
+          fail(ws, type, "boardId, taskId, summary, and a valid activity kind required");
+          return true;
+        }
+        const requestedOutcome = payload?.outcome;
+        const outcome = allowedOutcomes.includes(requestedOutcome) ? requestedOutcome : "unknown";
+        const board = await recordTaskActivity(
+          ctx.projectRoot,
+          boardId,
+          taskId,
+          {
+            kind,
+            summary: summary.trim(),
+            outcome,
+            ...typeof payload?.details === "string" && payload.details.trim() ? { details: payload.details.trim() } : {}
+          },
+          activityContext(
+            ctx,
+            payload?.actor ?? ctx.context?.agentId ?? "webui"
+          )
+        );
+        board ? ok(ws, type, board) : fail(ws, type, "Board or task not found");
         return true;
       }
       case "kanban.column.add": {
@@ -11142,6 +12532,18 @@ async function handleSpecsRoute(_ws, msg, handlers) {
 }
 
 // src/server/message-dispatcher.ts
+var chronicleCache = /* @__PURE__ */ new Map();
+async function chronicleEngine(projectRoot) {
+  const now = Date.now();
+  const cached = chronicleCache.get(projectRoot);
+  if (cached && now - cached.loadedAt < 6e4) return cached.engine;
+  const paths = resolveWstackPaths2({ projectRoot, userHome: os2.homedir() });
+  const engine = await ChronicleQueryEngine.fromDirectory(
+    path20.join(paths.projectDir, "chronicle")
+  );
+  chronicleCache.set(projectRoot, { loadedAt: now, engine });
+  return engine;
+}
 function createMessageDispatcher(opts) {
   const { state, deps: deps2, cb, routes, promptsCtx, codebaseIndexing, runLock, pendingConfirms } = opts;
   function makeWorklistContext() {
@@ -11153,7 +12555,8 @@ function createMessageDispatcher(opts) {
         state: deps2.context.state
       },
       send: (w, m) => send(w, m),
-      broadcast: (m) => broadcast(state.getClients(), m)
+      broadcast: (m) => broadcast(state.getClients(), m),
+      replaceTodos: (todos) => deps2.context.state.replaceTodos(todos)
     };
   }
   function makeSkillsContext() {
@@ -11162,7 +12565,7 @@ function createMessageDispatcher(opts) {
       skillLoader: deps2.skillLoader,
       skillInstaller: deps2.skillInstaller,
       projectRoot,
-      projectSkillsDir: path18.join(projectRoot, ".wrongstack", "skills"),
+      projectSkillsDir: path20.join(projectRoot, ".wrongstack", "skills"),
       globalSkillsDir: deps2.wpaths.globalSkills
     };
   }
@@ -11200,7 +12603,7 @@ function createMessageDispatcher(opts) {
     if (await handleMailboxRoute(ws, msg, routes.mailboxRoutes)) return;
     if (await handleMcpRoute(ws, msg, routes.mcpRoutes)) return;
     if (await handleBrainRoute(ws, msg, routes.brainRoutes)) return;
-    if (await handleAutoPhaseRoute(ws, msg, routes.autoPhaseRoutes)) return;
+    if (await handleGoalRoute(ws, msg, routes.goalRoutes)) return;
     if (await handleSpecsRoute(ws, msg, routes.specsRoutes)) return;
     if (await handleSddBoardRoute(ws, msg, routes.sddBoardRoutes)) return;
     if (await handleSddWizardRoute(ws, msg, routes.sddWizardRoutes)) return;
@@ -11404,6 +12807,14 @@ function createMessageDispatcher(opts) {
         return handleSuperMemoryDelete(ws, msg, deps2.memoryStore);
       case "memory.super.remember":
         return handleSuperMemoryRemember(ws, msg, deps2.memoryStore);
+      case "memory.super.recover":
+        return handleSuperMemoryRecover(ws, msg, deps2.memoryStore);
+      case "memory.super.candidateResolve":
+        return handleSuperMemoryCandidateResolve(ws, msg, deps2.memoryStore);
+      case "memory.super.backfillRecoverable":
+        return handleSuperMemoryBackfillRecoverable(ws, msg, deps2.memoryStore);
+      case "memory.super.forFile":
+        return handleSuperMemoryForFile(ws, msg, deps2.memoryStore);
       // ── MCP tripwires — handleMcpRoute claims these upstream. ──
       case "mcp.list":
         throw new Error("handleMcpRoute did not claim mcp.list \u2014 check chain order");
@@ -11634,6 +13045,59 @@ function createMessageDispatcher(opts) {
         });
         break;
       }
+      // ── Chronicle journal queries (parity with embedded webui-server) ──
+      // Mirrors packages/cli/src/webui-server/message-router.ts:645-664.
+      // The engine is cached for 1s to avoid re-reading the journal on every
+      // query; the cache is module-scoped so it survives across messages on
+      // the same connection.
+      case "chronicle.query": {
+        const payload = msg.payload ?? {};
+        const engine = await chronicleEngine(state.getProjectRoot());
+        send(ws, { type: "chronicle.query_result", payload: await engine.query(payload.query ?? {}) });
+        break;
+      }
+      case "chronicle.facet": {
+        const payload = msg.payload ?? {};
+        const allowed = /* @__PURE__ */ new Set([
+          "eventType",
+          "outcome",
+          "projectId",
+          "sessionId",
+          "agentId",
+          "taskId",
+          "providerId",
+          "modelId",
+          "resourceKind",
+          "resourcePath",
+          "toolCallId"
+        ]);
+        if (!payload.field || !allowed.has(payload.field)) {
+          send(ws, {
+            type: "chronicle.error",
+            payload: { message: "Invalid Chronicle facet field." }
+          });
+          break;
+        }
+        const engine = await chronicleEngine(state.getProjectRoot());
+        send(ws, {
+          type: "chronicle.facet_result",
+          payload: {
+            field: payload.field,
+            values: await engine.facet(payload.field, payload.query ?? {}, payload.limit),
+            diagnostics: engine.diagnostics
+          }
+        });
+        break;
+      }
+      case "chronicle.graph": {
+        const payload = msg.payload ?? {};
+        const engine = await chronicleEngine(state.getProjectRoot());
+        send(ws, {
+          type: "chronicle.graph_result",
+          payload: await engine.graph(payload.seed ?? {}, payload.hops, payload.maxNodes)
+        });
+        break;
+      }
       case "process.list": {
         await handleProcessList(ws);
         break;
@@ -11651,7 +13115,7 @@ function createMessageDispatcher(opts) {
         process.kill(process.pid, "SIGINT");
         break;
       }
-      case "goal.get": {
+      case "goal-state.get": {
         await handleGoalGet(state.getProjectRoot(), (m) => broadcast(state.getClients(), m));
         break;
       }
@@ -11685,9 +13149,9 @@ function createMessageDispatcher(opts) {
 }
 
 // src/server/pref-helpers.ts
-import { atomicWrite as atomicWrite6 } from "@wrongstack/core/utils";
+import * as fs14 from "node:fs/promises";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets as encryptConfigSecrets2 } from "@wrongstack/core/security";
-import * as fs13 from "node:fs/promises";
+import { atomicWrite as atomicWrite6, FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS2 } from "@wrongstack/core/utils";
 var PREF_KEYS = [
   "autonomy",
   "autonomyDelayMs",
@@ -11732,6 +13196,7 @@ var PREF_KEYS = [
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "modelMatrix",
   "fallbackAuto",
   // Refiner + TUI visual prefs (parity with the CLI's embedded server —
@@ -11742,11 +13207,31 @@ var PREF_KEYS = [
   "thinkingWord",
   "statuslineMode",
   "animationStyle",
+  "showModelReasoning",
   // Safety / system prefs (parity with /settings breaker, fs-access, debug-stream).
   "breakerEnabled",
   "breakerAutoKillResetMs",
   "fsAccess",
-  "debugStream"
+  "debugStream",
+  // Chimera (post-session) + auto-review (mid-session) settings.
+  // Persisted to config.extensions['wstack-chimera'] / ['wstack-auto-review']
+  // so the running plugins pick up changes after a session restart.
+  "chimeraEnabled",
+  "chimeraProvider",
+  "chimeraModel",
+  "chimeraMaxFiles",
+  "chimeraAutoFix",
+  "autoReviewEnabled",
+  "autoReviewProvider",
+  "autoReviewModel",
+  "autoReviewFallbackProfile",
+  "autoReviewFallbackModels",
+  "autoReviewDebounceMs",
+  "autoReviewMaxFilesPerBatch",
+  "autoReviewMaxConcurrentReviews",
+  "autoReviewCascadeOn",
+  // Per-plugin enable/disable map (parity with the embedded server).
+  "pluginsEnabled"
 ];
 function prefSnapshot(contextMeta) {
   const snapshot = {};
@@ -11760,7 +13245,7 @@ async function updateGlobalConfig(deps2, holder, mutate, errorLabel) {
   const write = async () => {
     let raw;
     try {
-      raw = await fs13.readFile(globalConfigPath, "utf8");
+      raw = await fs14.readFile(globalConfigPath, "utf8");
     } catch {
       raw = "{}";
     }
@@ -11784,219 +13269,264 @@ async function updateGlobalConfig(deps2, holder, mutate, errorLabel) {
   try {
     await next;
   } catch (err) {
-    logger.warn(`${errorLabel}: failed to persist to config: ${err instanceof Error ? err.message : String(err)}`);
+    logger.warn(
+      `${errorLabel}: failed to persist to config: ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
 async function persistPrefsToConfig(deps2, holder, payload) {
-  return updateGlobalConfig(deps2, holder, (decrypted) => {
-    const autonomyCfg = decrypted.autonomy ?? {};
-    let autonomyTouched = false;
-    const setAutonomy = (key, val) => {
-      autonomyCfg[key] = val;
-      autonomyTouched = true;
-    };
-    if (typeof payload["autonomy"] === "string" && ["off", "suggest", "auto"].includes(payload["autonomy"])) {
-      setAutonomy("defaultMode", payload["autonomy"]);
-    }
-    if (typeof payload["autonomyDelayMs"] === "number")
-      setAutonomy("autoProceedDelayMs", payload["autonomyDelayMs"]);
-    if (typeof payload["autoProceedMaxIterations"] === "number")
-      setAutonomy("autoProceedMaxIterations", payload["autoProceedMaxIterations"]);
-    if (typeof payload["yolo"] === "boolean") {
-      setAutonomy("yolo", payload["yolo"]);
-      decrypted.yolo = payload["yolo"];
-    }
-    if (typeof payload["chime"] === "boolean") setAutonomy("chime", payload["chime"]);
-    if (typeof payload["confirmExit"] === "boolean")
-      setAutonomy("confirmExit", payload["confirmExit"]);
-    if (typeof payload["streamFleet"] === "boolean")
-      setAutonomy("streamFleet", payload["streamFleet"]);
-    if (typeof payload["enhanceEnabled"] === "boolean")
-      setAutonomy("enhance", payload["enhanceEnabled"]);
-    if (typeof payload["enhanceDelayMs"] === "number")
-      setAutonomy("enhanceDelayMs", payload["enhanceDelayMs"]);
-    if (typeof payload["enhanceLanguage"] === "string")
-      setAutonomy("enhanceLanguage", payload["enhanceLanguage"]);
-    if (typeof payload["refinerProvider"] === "string")
-      setAutonomy("refinerProvider", payload["refinerProvider"]);
-    if (typeof payload["refinerModel"] === "string")
-      setAutonomy("refinerModel", payload["refinerModel"]);
-    if (typeof payload["refinerFallbackProfile"] === "string")
-      setAutonomy("refinerFallbackProfile", payload["refinerFallbackProfile"]);
-    if (typeof payload["thinkingWord"] === "string")
-      setAutonomy("thinkingWord", payload["thinkingWord"]);
-    if (typeof payload["statuslineMode"] === "string")
-      setAutonomy("statuslineMode", payload["statuslineMode"]);
-    if (typeof payload["animationStyle"] === "string")
-      setAutonomy("animationStyle", payload["animationStyle"]);
-    if (autonomyTouched) decrypted.autonomy = autonomyCfg;
-    if (typeof payload["nextPrediction"] === "boolean")
-      decrypted.nextPrediction = payload["nextPrediction"];
-    if (typeof payload["uiLocale"] === "string") decrypted.uiLocale = payload["uiLocale"];
-    if (Array.isArray(payload["fallbackModels"]))
-      decrypted.fallbackModels = payload["fallbackModels"];
-    if (payload["fallbackProfiles"] && typeof payload["fallbackProfiles"] === "object" && !Array.isArray(payload["fallbackProfiles"])) {
-      decrypted.fallbackProfiles = payload["fallbackProfiles"];
-    }
-    if (Array.isArray(payload["favoriteModels"]))
-      decrypted.favoriteModels = payload["favoriteModels"];
-    if (typeof payload["favoriteModelsOnly"] === "boolean")
-      decrypted.favoriteModelsOnly = payload["favoriteModelsOnly"];
-    if (payload["modelMatrix"] && typeof payload["modelMatrix"] === "object" && !Array.isArray(payload["modelMatrix"])) {
-      decrypted.modelMatrix = payload["modelMatrix"];
-    }
-    if (typeof payload["fallbackAuto"] === "boolean")
-      decrypted.fallbackAuto = payload["fallbackAuto"];
-    const FEATURE_MAP = {
-      featureMcp: "mcp",
-      featurePlugins: "plugins",
-      featureMemory: "memory",
-      featureSkills: "skills",
-      featureModelsRegistry: "modelsRegistry"
-    };
-    for (const [prefKey, cfgKey] of Object.entries(FEATURE_MAP)) {
-      if (typeof payload[prefKey] === "boolean") {
-        const feats = decrypted.features ?? {};
-        feats[cfgKey] = payload[prefKey];
-        decrypted.features = feats;
-      }
-    }
-    if (typeof payload["contextAutoCompact"] === "boolean" || typeof payload["contextStrategy"] === "string" || typeof payload["contextMode"] === "string") {
-      const ctxCfg = decrypted.context ?? {};
-      if (typeof payload["contextAutoCompact"] === "boolean")
-        ctxCfg.autoCompact = payload["contextAutoCompact"];
-      if (typeof payload["contextStrategy"] === "string")
-        ctxCfg.strategy = payload["contextStrategy"];
-      if (typeof payload["contextMode"] === "string") ctxCfg.mode = payload["contextMode"];
-      decrypted.context = ctxCfg;
-    }
-    if (typeof payload["tokenSavingTier"] === "string") {
-      const featsCfg = decrypted.features ?? {};
-      featsCfg.tokenSavingMode = payload["tokenSavingTier"];
-      decrypted.features = featsCfg;
-    }
-    if (typeof payload["maxConcurrent"] === "number") {
-      decrypted.maxConcurrent = payload["maxConcurrent"];
-    }
-    if (typeof payload["titleAnimation"] === "boolean") {
-      const autoCfg = decrypted.autonomy ?? {};
-      autoCfg.terminalTitleAnimation = payload["titleAnimation"];
-      decrypted.autonomy = autoCfg;
-    }
-    if (typeof payload["logLevel"] === "string") {
-      const logCfg = decrypted.log ?? {};
-      logCfg.level = payload["logLevel"];
-      decrypted.log = logCfg;
-    }
-    if (typeof payload["auditLevel"] === "string") {
-      const sessionCfg = decrypted.session ?? {};
-      sessionCfg.auditLevel = payload["auditLevel"];
-      decrypted.session = sessionCfg;
-    }
-    if (typeof payload["indexOnStart"] === "boolean") {
-      const indexingCfg = decrypted.indexing ?? {};
-      indexingCfg.onSessionStart = payload["indexOnStart"];
-      decrypted.indexing = indexingCfg;
-    }
-    if (typeof payload["maxIterations"] === "number") {
-      const toolsCfg = decrypted.tools ?? {};
-      toolsCfg.maxIterations = payload["maxIterations"];
-      decrypted.tools = toolsCfg;
-    }
-    const hqTouched = typeof payload["hqEnabled"] === "boolean" || typeof payload["hqUrl"] === "string" || typeof payload["hqToken"] === "string" || typeof payload["hqRawContent"] === "boolean";
-    if (hqTouched) {
-      const hqCfg = decrypted.hq ?? {};
-      if (typeof payload["hqEnabled"] === "boolean") hqCfg.enabled = payload["hqEnabled"];
-      if (typeof payload["hqUrl"] === "string") hqCfg.url = payload["hqUrl"];
-      if (typeof payload["hqToken"] === "string") hqCfg.token = payload["hqToken"];
-      if (typeof payload["hqRawContent"] === "boolean")
-        hqCfg.rawContent = payload["hqRawContent"];
-      decrypted.hq = hqCfg;
-    }
-    const tgTouched = typeof payload["tgSessionEnd"] === "boolean" || typeof payload["tgDelegate"] === "boolean" || typeof payload["tgLongToolMs"] === "number";
-    if (tgTouched) {
-      const ext = decrypted.extensions ?? {};
-      const tg = ext["telegram"] ?? {};
-      if (typeof payload["tgSessionEnd"] === "boolean") {
-        tg["notifyOnSessionEnd"] = payload["tgSessionEnd"];
-      }
-      if (typeof payload["tgDelegate"] === "boolean") {
-        tg["notifyOnDelegate"] = payload["tgDelegate"];
-      }
-      if (typeof payload["tgLongToolMs"] === "number") {
-        tg["longToolThresholdMs"] = payload["tgLongToolMs"];
-      }
-      ext["telegram"] = tg;
-      decrypted.extensions = ext;
-    }
-    const modelRuntimeTouched = typeof payload["reasoningMode"] === "string" || typeof payload["reasoningEffort"] === "string" || typeof payload["reasoningPreserve"] === "boolean" || typeof payload["cacheTtl"] === "string";
-    if (modelRuntimeTouched) {
-      const mr = decrypted.modelRuntime ?? {};
-      const reasoning = mr.reasoning ?? {};
-      if (typeof payload["reasoningMode"] === "string") reasoning.mode = payload["reasoningMode"];
-      if (typeof payload["reasoningEffort"] === "string")
-        reasoning.effort = payload["reasoningEffort"];
-      if (typeof payload["reasoningPreserve"] === "boolean")
-        reasoning.preserve = payload["reasoningPreserve"];
-      mr.reasoning = reasoning;
-      if (typeof payload["cacheTtl"] === "string" && payload["cacheTtl"] !== "default") {
-        mr.cache = { ttl: payload["cacheTtl"] };
-      } else if (payload["cacheTtl"] === "default") {
-        delete mr.cache;
-      }
-      decrypted.modelRuntime = mr;
-    }
-    if (typeof payload["breakerEnabled"] === "boolean" || typeof payload["breakerAutoKillResetMs"] === "number") {
-      const cb = decrypted.circuitBreaker ?? {};
-      if (typeof payload["breakerEnabled"] === "boolean") cb.enabled = payload["breakerEnabled"];
-      if (typeof payload["breakerAutoKillResetMs"] === "number")
-        cb.autoKillResetMs = payload["breakerAutoKillResetMs"];
-      decrypted.circuitBreaker = cb;
-    }
-    if (payload["fsAccess"] === "unrestricted" || payload["fsAccess"] === "project") {
-      const restrict = payload["fsAccess"] === "project";
-      const toolsCfg = decrypted.tools ?? {};
-      toolsCfg.restrictToProjectRoot = restrict;
-      decrypted.tools = toolsCfg;
-      const featsCfg = decrypted.features ?? {};
-      featsCfg.allowOutsideProjectRoot = !restrict;
-      decrypted.features = featsCfg;
-    }
-    if (typeof payload["debugStream"] === "boolean")
-      decrypted.debugStream = payload["debugStream"];
-  }, "prefs");
-}
-
-// src/server/projects-manifest.ts
-import * as fs14 from "node:fs/promises";
-import * as path19 from "node:path";
-import { projectSlug } from "@wrongstack/core";
-function projectsJsonPath(globalConfigPath) {
-  const base = path19.dirname(globalConfigPath);
-  return path19.join(base, "projects.json");
-}
-async function loadManifest(globalConfigPath) {
-  try {
-    const raw = await fs14.readFile(projectsJsonPath(globalConfigPath), "utf8");
-    const parsed = JSON.parse(raw);
-    return { projects: parsed.projects ?? [] };
-  } catch {
-    return { projects: [] };
-  }
-}
-async function saveManifest(manifest, globalConfigPath) {
-  const file = projectsJsonPath(globalConfigPath);
-  await fs14.mkdir(path19.dirname(file), { recursive: true });
-  await fs14.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
-}
-function generateProjectSlug(rootPath) {
-  return projectSlug(rootPath);
-}
-async function ensureProjectDataDir(slug, globalConfigPath) {
-  const base = path19.dirname(globalConfigPath);
-  const dir = path19.join(base, "projects", slug);
-  await fs14.mkdir(dir, { recursive: true });
-  return dir;
+  return updateGlobalConfig(
+    deps2,
+    holder,
+    (decrypted) => {
+      const autonomyCfg = decrypted.autonomy ?? {};
+      let autonomyTouched = false;
+      const setAutonomy = (key, val) => {
+        autonomyCfg[key] = val;
+        autonomyTouched = true;
+      };
+      if (typeof payload["autonomy"] === "string" && ["off", "suggest", "auto"].includes(payload["autonomy"])) {
+        setAutonomy("defaultMode", payload["autonomy"]);
+      }
+      if (typeof payload["autonomyDelayMs"] === "number")
+        setAutonomy("autoProceedDelayMs", payload["autonomyDelayMs"]);
+      if (typeof payload["autoProceedMaxIterations"] === "number")
+        setAutonomy("autoProceedMaxIterations", payload["autoProceedMaxIterations"]);
+      if (typeof payload["yolo"] === "boolean") {
+        setAutonomy("yolo", payload["yolo"]);
+        decrypted.yolo = payload["yolo"];
+      }
+      if (typeof payload["chime"] === "boolean") setAutonomy("chime", payload["chime"]);
+      if (typeof payload["confirmExit"] === "boolean")
+        setAutonomy("confirmExit", payload["confirmExit"]);
+      if (typeof payload["streamFleet"] === "boolean")
+        setAutonomy("streamFleet", payload["streamFleet"]);
+      if (typeof payload["enhanceEnabled"] === "boolean")
+        setAutonomy("enhance", payload["enhanceEnabled"]);
+      if (typeof payload["enhanceDelayMs"] === "number")
+        setAutonomy("enhanceDelayMs", payload["enhanceDelayMs"]);
+      if (typeof payload["enhanceLanguage"] === "string")
+        setAutonomy("enhanceLanguage", payload["enhanceLanguage"]);
+      if (typeof payload["refinerProvider"] === "string")
+        setAutonomy("refinerProvider", payload["refinerProvider"]);
+      if (typeof payload["refinerModel"] === "string")
+        setAutonomy("refinerModel", payload["refinerModel"]);
+      if (typeof payload["refinerFallbackProfile"] === "string")
+        setAutonomy("refinerFallbackProfile", payload["refinerFallbackProfile"]);
+      if (typeof payload["thinkingWord"] === "string")
+        setAutonomy("thinkingWord", payload["thinkingWord"]);
+      if (typeof payload["statuslineMode"] === "string")
+        setAutonomy("statuslineMode", payload["statuslineMode"]);
+      if (typeof payload["animationStyle"] === "string")
+        setAutonomy("animationStyle", payload["animationStyle"]);
+      if (typeof payload["showModelReasoning"] === "boolean")
+        setAutonomy("showModelReasoning", payload["showModelReasoning"]);
+      if (autonomyTouched) decrypted.autonomy = autonomyCfg;
+      if (typeof payload["nextPrediction"] === "boolean")
+        decrypted.nextPrediction = payload["nextPrediction"];
+      if (typeof payload["uiLocale"] === "string") decrypted.uiLocale = payload["uiLocale"];
+      if (Array.isArray(payload["fallbackModels"]))
+        decrypted.fallbackModels = payload["fallbackModels"];
+      if (payload["fallbackProfiles"] && typeof payload["fallbackProfiles"] === "object" && !Array.isArray(payload["fallbackProfiles"])) {
+        decrypted.fallbackProfiles = payload["fallbackProfiles"];
+      }
+      if (Array.isArray(payload["favoriteModels"]))
+        decrypted.favoriteModels = payload["favoriteModels"];
+      if (typeof payload["favoriteModelsOnly"] === "boolean")
+        decrypted.favoriteModelsOnly = payload["favoriteModelsOnly"];
+      if (Array.isArray(payload["modelAvailabilitySchedule"]))
+        decrypted.modelAvailabilitySchedule = payload["modelAvailabilitySchedule"];
+      if (payload["modelMatrix"] && typeof payload["modelMatrix"] === "object" && !Array.isArray(payload["modelMatrix"])) {
+        decrypted.modelMatrix = payload["modelMatrix"];
+      }
+      if (typeof payload["fallbackAuto"] === "boolean")
+        decrypted.fallbackAuto = payload["fallbackAuto"];
+      const FEATURE_MAP = {
+        featureMcp: "mcp",
+        featurePlugins: "plugins",
+        featureMemory: "memory",
+        featureSkills: "skills",
+        featureModelsRegistry: "modelsRegistry"
+      };
+      for (const [prefKey, cfgKey] of Object.entries(FEATURE_MAP)) {
+        if (typeof payload[prefKey] === "boolean") {
+          const feats = decrypted.features ?? {};
+          feats[cfgKey] = payload[prefKey];
+          decrypted.features = feats;
+        }
+      }
+      if (typeof payload["contextAutoCompact"] === "boolean" || typeof payload["contextStrategy"] === "string" || typeof payload["contextMode"] === "string") {
+        const ctxCfg = decrypted.context ?? {};
+        if (typeof payload["contextAutoCompact"] === "boolean")
+          ctxCfg.autoCompact = payload["contextAutoCompact"];
+        if (typeof payload["contextStrategy"] === "string")
+          ctxCfg.strategy = payload["contextStrategy"];
+        if (typeof payload["contextMode"] === "string") ctxCfg.mode = payload["contextMode"];
+        decrypted.context = ctxCfg;
+      }
+      if (typeof payload["tokenSavingTier"] === "string") {
+        const featsCfg = decrypted.features ?? {};
+        featsCfg.tokenSavingMode = payload["tokenSavingTier"];
+        decrypted.features = featsCfg;
+      }
+      if (typeof payload["maxConcurrent"] === "number") {
+        decrypted.maxConcurrent = payload["maxConcurrent"];
+      }
+      if (typeof payload["titleAnimation"] === "boolean") {
+        const autoCfg = decrypted.autonomy ?? {};
+        autoCfg.terminalTitleAnimation = payload["titleAnimation"];
+        decrypted.autonomy = autoCfg;
+      }
+      if (typeof payload["logLevel"] === "string") {
+        const logCfg = decrypted.log ?? {};
+        logCfg.level = payload["logLevel"];
+        decrypted.log = logCfg;
+      }
+      if (typeof payload["auditLevel"] === "string") {
+        const sessionCfg = decrypted.session ?? {};
+        sessionCfg.auditLevel = payload["auditLevel"];
+        decrypted.session = sessionCfg;
+      }
+      if (typeof payload["indexOnStart"] === "boolean") {
+        const indexingCfg = decrypted.indexing ?? {};
+        indexingCfg.onSessionStart = payload["indexOnStart"];
+        decrypted.indexing = indexingCfg;
+      }
+      if (typeof payload["maxIterations"] === "number") {
+        const toolsCfg = decrypted.tools ?? {};
+        toolsCfg.maxIterations = payload["maxIterations"];
+        decrypted.tools = toolsCfg;
+      }
+      const hqTouched = typeof payload["hqEnabled"] === "boolean" || typeof payload["hqUrl"] === "string" || typeof payload["hqToken"] === "string" || typeof payload["hqRawContent"] === "boolean";
+      if (hqTouched) {
+        const hqCfg = decrypted.hq ?? {};
+        if (typeof payload["hqEnabled"] === "boolean") hqCfg.enabled = payload["hqEnabled"];
+        if (typeof payload["hqUrl"] === "string") hqCfg.url = payload["hqUrl"];
+        if (typeof payload["hqToken"] === "string") hqCfg.token = payload["hqToken"];
+        if (typeof payload["hqRawContent"] === "boolean")
+          hqCfg.rawContent = payload["hqRawContent"];
+        decrypted.hq = hqCfg;
+      }
+      const tgTouched = typeof payload["tgSessionEnd"] === "boolean" || typeof payload["tgDelegate"] === "boolean" || typeof payload["tgLongToolMs"] === "number";
+      if (tgTouched) {
+        const ext = decrypted.extensions ?? {};
+        const tg = ext["telegram"] ?? {};
+        if (typeof payload["tgSessionEnd"] === "boolean") {
+          tg["notifyOnSessionEnd"] = payload["tgSessionEnd"];
+        }
+        if (typeof payload["tgDelegate"] === "boolean") {
+          tg["notifyOnDelegate"] = payload["tgDelegate"];
+        }
+        if (typeof payload["tgLongToolMs"] === "number") {
+          tg["longToolThresholdMs"] = payload["tgLongToolMs"];
+        }
+        ext["telegram"] = tg;
+        decrypted.extensions = ext;
+      }
+      const modelRuntimeTouched = typeof payload["reasoningMode"] === "string" || typeof payload["reasoningEffort"] === "string" || typeof payload["reasoningPreserve"] === "boolean" || typeof payload["cacheTtl"] === "string";
+      if (modelRuntimeTouched) {
+        const mr = decrypted.modelRuntime ?? {};
+        const reasoning = mr.reasoning ?? {};
+        if (typeof payload["reasoningMode"] === "string") reasoning.mode = payload["reasoningMode"];
+        if (typeof payload["reasoningEffort"] === "string")
+          reasoning.effort = payload["reasoningEffort"];
+        if (typeof payload["reasoningPreserve"] === "boolean")
+          reasoning.preserve = payload["reasoningPreserve"];
+        mr.reasoning = reasoning;
+        if (typeof payload["cacheTtl"] === "string" && payload["cacheTtl"] !== "default") {
+          mr.cache = { ttl: payload["cacheTtl"] };
+        } else if (payload["cacheTtl"] === "default") {
+          delete mr.cache;
+        }
+        decrypted.modelRuntime = mr;
+      }
+      if (typeof payload["breakerEnabled"] === "boolean" || typeof payload["breakerAutoKillResetMs"] === "number") {
+        const cb = decrypted.circuitBreaker ?? {};
+        if (typeof payload["breakerEnabled"] === "boolean") cb.enabled = payload["breakerEnabled"];
+        if (typeof payload["breakerAutoKillResetMs"] === "number")
+          cb.autoKillResetMs = payload["breakerAutoKillResetMs"];
+        decrypted.circuitBreaker = cb;
+      }
+      if (payload["fsAccess"] === "unrestricted" || payload["fsAccess"] === "project") {
+        const restrict = payload["fsAccess"] === "project";
+        const toolsCfg = decrypted.tools ?? {};
+        toolsCfg.restrictToProjectRoot = restrict;
+        decrypted.tools = toolsCfg;
+        const featsCfg = decrypted.features ?? {};
+        featsCfg.allowOutsideProjectRoot = !restrict;
+        decrypted.features = featsCfg;
+      }
+      if (typeof payload["debugStream"] === "boolean")
+        decrypted.debugStream = payload["debugStream"];
+      if (typeof payload["pluginsEnabled"] === "object" && payload["pluginsEnabled"] !== null) {
+        const ext = decrypted.extensions ?? {};
+        for (const [pluginName, enabled] of Object.entries(
+          payload["pluginsEnabled"]
+        )) {
+          if (FORBIDDEN_PROTO_KEYS2.has(pluginName)) continue;
+          const pExt = ext[pluginName] ?? {};
+          pExt["enabled"] = enabled;
+          ext[pluginName] = pExt;
+        }
+        decrypted.extensions = ext;
+      }
+      const chimeraTouched = typeof payload["chimeraEnabled"] === "boolean" || typeof payload["chimeraProvider"] === "string" || typeof payload["chimeraModel"] === "string" || typeof payload["chimeraMaxFiles"] === "number" || typeof payload["chimeraAutoFix"] === "string";
+      if (chimeraTouched) {
+        const ext = decrypted.extensions ?? {};
+        const chimera = ext["wstack-chimera"] ?? {};
+        if (typeof payload["chimeraEnabled"] === "boolean")
+          chimera["enabled"] = payload["chimeraEnabled"];
+        if (typeof payload["chimeraProvider"] === "string")
+          chimera["provider"] = payload["chimeraProvider"];
+        if (typeof payload["chimeraModel"] === "string") chimera["model"] = payload["chimeraModel"];
+        if (typeof payload["chimeraMaxFiles"] === "number" && payload["chimeraMaxFiles"] >= 1) {
+          chimera["maxFiles"] = payload["chimeraMaxFiles"];
+        }
+        if (typeof payload["chimeraAutoFix"] === "string") {
+          if (payload["chimeraAutoFix"] === "off" || payload["chimeraAutoFix"] === "ask" || payload["chimeraAutoFix"] === "auto") {
+            chimera["autoFix"] = payload["chimeraAutoFix"];
+          }
+        }
+        ext["wstack-chimera"] = chimera;
+        decrypted.extensions = ext;
+      }
+      const autoReviewTouched = typeof payload["autoReviewEnabled"] === "boolean" || typeof payload["autoReviewProvider"] === "string" || typeof payload["autoReviewModel"] === "string" || typeof payload["autoReviewFallbackProfile"] === "string" || Array.isArray(payload["autoReviewFallbackModels"]) || typeof payload["autoReviewDebounceMs"] === "number" || typeof payload["autoReviewMaxFilesPerBatch"] === "number" || typeof payload["autoReviewMaxConcurrentReviews"] === "number" || typeof payload["autoReviewCascadeOn"] === "string";
+      if (autoReviewTouched) {
+        const ext = decrypted.extensions ?? {};
+        const ar = ext["wstack-auto-review"] ?? {};
+        if (typeof payload["autoReviewEnabled"] === "boolean")
+          ar["enabled"] = payload["autoReviewEnabled"];
+        if (typeof payload["autoReviewProvider"] === "string")
+          ar["provider"] = payload["autoReviewProvider"];
+        if (typeof payload["autoReviewModel"] === "string")
+          ar["model"] = payload["autoReviewModel"];
+        if (typeof payload["autoReviewFallbackProfile"] === "string") {
+          if (payload["autoReviewFallbackProfile"] === "") {
+            delete ar["fallbackProfile"];
+          } else {
+            ar["fallbackProfile"] = payload["autoReviewFallbackProfile"];
+          }
+        }
+        if (typeof payload["autoReviewDebounceMs"] === "number" && payload["autoReviewDebounceMs"] >= 0) {
+          ar["debounceMs"] = payload["autoReviewDebounceMs"];
+        }
+        if (typeof payload["autoReviewMaxFilesPerBatch"] === "number" && payload["autoReviewMaxFilesPerBatch"] >= 1) {
+          ar["maxFilesPerBatch"] = payload["autoReviewMaxFilesPerBatch"];
+        }
+        if (typeof payload["autoReviewMaxConcurrentReviews"] === "number" && payload["autoReviewMaxConcurrentReviews"] >= 1) {
+          ar["maxConcurrentReviews"] = payload["autoReviewMaxConcurrentReviews"];
+        }
+        if (typeof payload["autoReviewCascadeOn"] === "string") {
+          if (payload["autoReviewCascadeOn"] === "off" || payload["autoReviewCascadeOn"] === "critical" || payload["autoReviewCascadeOn"] === "high") {
+            ar["cascadeOn"] = payload["autoReviewCascadeOn"];
+          }
+        }
+        ext["wstack-auto-review"] = ar;
+        decrypted.extensions = ext;
+      }
+    },
+    "prefs"
+  );
 }
 
 // src/server/provider-handlers.ts
@@ -12327,12 +13857,14 @@ function createProviderHandlers(deps2) {
 }
 
 // src/server/routes.ts
-import path21 from "node:path";
+import path22 from "node:path";
 import {
+  buildRefinerContextSections,
   enhanceUserPrompt,
   gatedEnhancerReasoning,
   nextEnhanceTimeout,
   recentTextTurns,
+  resolveConfiguredRefinerRef,
   resolveEnhanceFallbackRef,
   resolveProviderModelList
 } from "@wrongstack/core";
@@ -12444,7 +13976,7 @@ async function handleMailboxCompact(ws, deps2, opts) {
 // src/server/mode-handlers.ts
 import {
   DefaultSystemPromptBuilder as DefaultSystemPromptBuilder2,
-  resolveWstackPaths as resolveWstackPaths2,
+  resolveWstackPaths as resolveWstackPaths3,
   ToolValidationError as ToolValidationError5
 } from "@wrongstack/core";
 function createModeHandlers(ctx) {
@@ -12484,6 +14016,7 @@ function createModeHandlers(ctx) {
       }
       const { id } = parsed.value;
       try {
+        const prev = await ctx.modeStore.getActiveMode();
         if (id === "default") {
           await ctx.modeStore.setActiveMode(null);
         } else {
@@ -12494,8 +14027,13 @@ function createModeHandlers(ctx) {
           await ctx.modeStore.setActiveMode(id);
         }
         ctx.setModeId(id);
+        const fromMode = prev?.id ?? "default";
+        if (ctx.context.session && fromMode !== id) {
+          void ctx.context.session.append({ type: "mode_changed", ts: (/* @__PURE__ */ new Date()).toISOString(), from: fromMode, to: id }).catch(() => {
+          });
+        }
         const modePrompt = id === "default" ? "" : (await ctx.modeStore.getMode(id))?.prompt ?? "";
-        const paths = resolveWstackPaths2({ projectRoot: ctx.projectRoot, globalRoot: ctx.globalRoot });
+        const paths = resolveWstackPaths3({ projectRoot: ctx.projectRoot, globalRoot: ctx.globalRoot });
         const freshBuilder = new DefaultSystemPromptBuilder2({
           memoryStore: ctx.memoryStore,
           // Single injection channel: Super Memory turn middleware, not a static section.
@@ -12530,7 +14068,7 @@ function createModeHandlers(ctx) {
 }
 
 // src/server/project-handlers.ts
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 function createProjectHandlers(ctx) {
   return {
     listProjects: async (ws) => {
@@ -12556,7 +14094,7 @@ function createProjectHandlers(ctx) {
     selectProject: async (ws, msg) => {
       const payload = msg.payload;
       const root = typeof payload?.root === "string" ? payload.root : "";
-      const name2 = typeof payload?.name === "string" ? payload.name : root ? path20.basename(root) : "";
+      const name2 = typeof payload?.name === "string" ? payload.name : root ? path21.basename(root) : "";
       send(ws, {
         type: "projects.selected",
         payload: {
@@ -12593,6 +14131,7 @@ function createProjectHandlers(ctx) {
 // src/server/session-handlers.ts
 import {
   DEFAULT_CONTEXT_WINDOW_MODE_ID,
+  loadTodosCheckpoint,
   repairToolUseAdjacency,
   resolveContextWindowPolicy as resolveContextWindowPolicy3
 } from "@wrongstack/core";
@@ -12630,13 +14169,14 @@ function createSessionHandlers(ctx) {
     }).catch(() => void 0);
     await writer.close().catch(() => void 0);
   };
-  const activateSession = async (next, messages, usage) => {
+  const activateSession = async (next, messages, usage, todos = []) => {
     const current = ctx.getSession();
     if (current !== next) await finalizeSession(current);
     ctx.setSession(next);
     ctx.context.session = next;
     ctx.context.state.replaceMessages(messages);
-    ctx.context.state.replaceTodos([]);
+    await ctx.context.flushConversationJournal?.();
+    ctx.context.state.replaceTodos(todos);
     ctx.context.readFiles.clear();
     ctx.context.fileMtimes.clear();
     ctx.context.state.setMeta(
@@ -12920,7 +14460,15 @@ function createSessionHandlers(ctx) {
           return;
         }
         const resumed = await ctx.getSessionStore().resume(id);
-        await activateSession(resumed.writer, resumed.data.messages, resumed.data.usage);
+        const restoredTodos = await loadTodosCheckpoint(
+          sessionScopedPath2(ctx.sessionsDir, resumed.writer.id, ".todos.json")
+        ).catch(() => null) ?? [];
+        await activateSession(
+          resumed.writer,
+          resumed.data.messages,
+          resumed.data.usage,
+          restoredTodos
+        );
         broadcast(ctx.clients, {
           type: "session.start",
           payload: {
@@ -12930,6 +14478,10 @@ function createSessionHandlers(ctx) {
             replayUsage: resumed.data.usage
           }
         });
+        broadcast(ctx.clients, {
+          type: "todos.updated",
+          payload: { sessionId: resumed.writer.id, todos: restoredTodos }
+        });
         sendResult(ws, true, `Resumed session ${id}`);
       } catch (err) {
         sendResult(ws, false, errMessage(err));
@@ -12955,11 +14507,17 @@ function createSessionHandlers(ctx) {
       if (!ensureCurrentSession(ws, msg, "session.rewind")) return;
       const { checkpointIndex } = msg.payload;
       try {
-        const { DefaultSessionRewinder } = await import("@wrongstack/core");
+        const { applyRewindToConversation, DefaultSessionRewinder } = await import("@wrongstack/core");
         const projectRoot = ctx.getProjectRoot();
         const rewinder = new DefaultSessionRewinder(ctx.sessionsDir, projectRoot);
-        await rewinder.rewindToCheckpoint(ctx.getSession().id, checkpointIndex);
-        await ctx.context.session.truncateToCheckpoint(checkpointIndex);
+        const reverted = await rewinder.rewindToCheckpoint(ctx.getSession().id, checkpointIndex);
+        await applyRewindToConversation({
+          session: ctx.context.session,
+          state: ctx.context.state,
+          sessionsDir: ctx.sessionsDir,
+          promptIndex: checkpointIndex,
+          revertedFiles: reverted.revertedFiles
+        });
         sendResult(ws, true, `Rewound to checkpoint ${checkpointIndex}`);
         broadcast(ctx.clients, {
           type: "session.start",
@@ -13169,11 +14727,36 @@ function buildRoutes(state, deps2, cb) {
           });
           return;
         }
+      } else {
+        const configuredRef = resolveConfiguredRefinerRef({
+          ...cfg,
+          provider: providerId,
+          model
+        });
+        if (configuredRef) {
+          const slash = configuredRef.indexOf("/");
+          const configuredProvider = slash > 0 ? configuredRef.slice(0, slash) : providerId;
+          const configuredModel = slash > 0 ? configuredRef.slice(slash + 1) : configuredRef;
+          try {
+            const providerCfg = cfg.providers?.[configuredProvider] ?? {
+              type: configuredProvider
+            };
+            provider = deps2.providerRegistry.has(configuredProvider) ? deps2.providerRegistry.create({ ...providerCfg, type: configuredProvider }) : makeProviderFromConfig2(configuredProvider, providerCfg);
+            providerId = configuredProvider;
+            model = configuredModel;
+          } catch {
+          }
+        }
       }
       const baseTimeout = 9e4;
       const timeoutMs = typeof payload.timeoutMs === "number" && payload.timeoutMs > 0 ? payload.timeoutMs : baseTimeout;
       try {
         const history = recentTextTurns(deps2.context.messages);
+        const contextSections = await buildRefinerContextSections({
+          text,
+          memoryStore: deps2.memoryStore,
+          context: deps2.context
+        });
         const resolved = await resolveProviderModelMetadata(
           deps2.modelsRegistry,
           providerId,
@@ -13187,6 +14770,14 @@ function buildRoutes(state, deps2, cb) {
           model,
           text,
           history,
+          contextSections,
+          ...payload.previousRefined ? {
+            previousRefinement: {
+              refined: payload.previousRefined,
+              english: payload.previousEnglish || payload.previousRefined
+            }
+          } : {},
+          ...payload.retryFeedback ? { retryFeedback: payload.retryFeedback } : {},
           timeoutMs,
           ...reasoning ? { reasoning } : {},
           onError: (reason, kind) => {
@@ -13342,10 +14933,29 @@ function buildRoutes(state, deps2, cb) {
         cfg.favoriteModels = payload["favoriteModels"];
       if (typeof payload["favoriteModelsOnly"] === "boolean")
         cfg.favoriteModelsOnly = payload["favoriteModelsOnly"];
+      if (Array.isArray(payload["modelAvailabilitySchedule"]))
+        cfg.modelAvailabilitySchedule = payload["modelAvailabilitySchedule"];
       if (payload["modelMatrix"] && typeof payload["modelMatrix"] === "object" && !Array.isArray(payload["modelMatrix"])) {
         cfg.modelMatrix = payload["modelMatrix"];
       }
       if (typeof payload["fallbackAuto"] === "boolean") cfg.fallbackAuto = payload["fallbackAuto"];
+      const routingPatch = {};
+      if (Array.isArray(payload["fallbackModels"]))
+        routingPatch.fallbackModels = payload["fallbackModels"];
+      if (payload["fallbackProfiles"] && typeof payload["fallbackProfiles"] === "object" && !Array.isArray(payload["fallbackProfiles"]))
+        routingPatch.fallbackProfiles = payload["fallbackProfiles"];
+      if (Array.isArray(payload["favoriteModels"]))
+        routingPatch.favoriteModels = payload["favoriteModels"];
+      if (typeof payload["favoriteModelsOnly"] === "boolean")
+        routingPatch.favoriteModelsOnly = payload["favoriteModelsOnly"];
+      if (Array.isArray(payload["modelAvailabilitySchedule"]))
+        routingPatch.modelAvailabilitySchedule = payload["modelAvailabilitySchedule"];
+      if (payload["modelMatrix"] && typeof payload["modelMatrix"] === "object" && !Array.isArray(payload["modelMatrix"]))
+        routingPatch.modelMatrix = payload["modelMatrix"];
+      if (typeof payload["fallbackAuto"] === "boolean")
+        routingPatch.fallbackAuto = payload["fallbackAuto"];
+      if (Object.keys(routingPatch).length > 0)
+        deps2.configStore.update(routingPatch);
       if (typeof payload["contextAutoCompact"] === "boolean") {
         if (payload["contextAutoCompact"] && deps2.autoCompactor) {
           deps2.pipelines.contextWindow.remove("AutoCompaction", { optional: true });
@@ -13414,7 +15024,7 @@ function buildRoutes(state, deps2, cb) {
       }
       return handleMailboxMessages(
         ws,
-        { projectRoot: state.getProjectRoot(), globalRoot: path21.dirname(deps2.globalConfigPath) },
+        { projectRoot: state.getProjectRoot(), globalRoot: path22.dirname(deps2.globalConfigPath) },
         parsed.value
       );
     },
@@ -13426,13 +15036,13 @@ function buildRoutes(state, deps2, cb) {
       }
       return handleMailboxAgents(
         ws,
-        { projectRoot: state.getProjectRoot(), globalRoot: path21.dirname(deps2.globalConfigPath) },
+        { projectRoot: state.getProjectRoot(), globalRoot: path22.dirname(deps2.globalConfigPath) },
         parsed.value
       );
     },
     clear: (ws) => handleMailboxClear(ws, {
       projectRoot: state.getProjectRoot(),
-      globalRoot: path21.dirname(deps2.globalConfigPath)
+      globalRoot: path22.dirname(deps2.globalConfigPath)
     }),
     purge: (ws, msg) => {
       const parsed = validateMailboxPurgePayload(msg.payload);
@@ -13442,14 +15052,14 @@ function buildRoutes(state, deps2, cb) {
       }
       return handleMailboxPurge(
         ws,
-        { projectRoot: state.getProjectRoot(), globalRoot: path21.dirname(deps2.globalConfigPath) },
+        { projectRoot: state.getProjectRoot(), globalRoot: path22.dirname(deps2.globalConfigPath) },
         parsed.value
       );
     },
     compact: (ws, msg) => {
       return handleMailboxCompact(
         ws,
-        { projectRoot: state.getProjectRoot(), globalRoot: path21.dirname(deps2.globalConfigPath) },
+        { projectRoot: state.getProjectRoot(), globalRoot: path22.dirname(deps2.globalConfigPath) },
         msg.payload ?? {}
       );
     }
@@ -13558,8 +15168,8 @@ function buildRoutes(state, deps2, cb) {
       }
     }
   };
-  const autoPhaseRoutes = {
-    handleMessage: (msg) => deps2.autoPhaseHandler.handleMessage(msg)
+  const goalRoutes = {
+    handleMessage: (msg) => deps2.goalHandler.handleMessage(msg)
   };
   const specsRoutes = {
     handleMessage: (msg) => deps2.specsHandler.handleMessage(msg)
@@ -13580,7 +15190,7 @@ function buildRoutes(state, deps2, cb) {
     mailboxRoutes,
     mcpRoutes,
     brainRoutes,
-    autoPhaseRoutes,
+    goalRoutes,
     specsRoutes,
     sddBoardRoutes,
     sddWizardRoutes
@@ -13701,7 +15311,7 @@ async function startWebUI(opts = {}) {
     brainLog,
     brainMonitor,
     codebaseIndexing,
-    autoPhaseHandler,
+    goalHandler,
     specsHandler,
     sddBoardHandler,
     sddWizardHandler,
@@ -13762,21 +15372,21 @@ async function startWebUI(opts = {}) {
     wpaths
   }, watcherMetricsRef);
   async function touchProjectEntry(root, workDir) {
-    const resolved = path22.resolve(root);
+    const resolved = path23.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = manifest.projects.find((p) => path22.resolve(p.root) === resolved);
+    const existing = manifest.projects.find((p) => path23.resolve(p.root) === resolved);
     if (existing) {
       existing.lastSeen = now;
-      if (workDir) existing.lastWorkingDir = path22.resolve(workDir);
+      if (workDir) existing.lastWorkingDir = path23.resolve(workDir);
     } else {
       manifest.projects.push({
-        name: path22.basename(resolved),
+        name: path23.basename(resolved),
         root: resolved,
         slug: generateProjectSlug(resolved),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: workDir ? path22.resolve(workDir) : void 0
+        lastWorkingDir: workDir ? path23.resolve(workDir) : void 0
       });
     }
     await saveManifest(manifest, globalConfigPath);
@@ -13859,7 +15469,7 @@ async function startWebUI(opts = {}) {
     httpPort,
     wssPrimary,
     wssSecondary,
-    autoPhaseHandler,
+    goalHandler,
     specsHandler,
     sddBoardHandler,
     sddWizardHandler,
@@ -13903,7 +15513,13 @@ async function startWebUI(opts = {}) {
         deps2.configStore.update({
           providers: snapshot.providers,
           ...snapshot.apiKey !== void 0 ? { apiKey: snapshot.apiKey } : {},
-          ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {}
+          ...snapshot.baseUrl !== void 0 ? { baseUrl: snapshot.baseUrl } : {},
+          ...snapshot.fallbackModels !== void 0 ? { fallbackModels: snapshot.fallbackModels } : {},
+          ...snapshot.fallbackProfiles !== void 0 ? { fallbackProfiles: snapshot.fallbackProfiles } : {},
+          ...snapshot.favoriteModels !== void 0 ? { favoriteModels: snapshot.favoriteModels } : {},
+          ...snapshot.favoriteModelsOnly !== void 0 ? { favoriteModelsOnly: snapshot.favoriteModelsOnly } : {},
+          ...snapshot.modelMatrix !== void 0 ? { modelMatrix: snapshot.modelMatrix } : {},
+          ...snapshot.fallbackAuto !== void 0 ? { fallbackAuto: snapshot.fallbackAuto } : {}
         });
         broadcast(clients, {
           type: "providers.saved",
@@ -13964,7 +15580,7 @@ async function startWebUI(opts = {}) {
     },
     clients,
     pendingConfirms,
-    autoPhaseHandler,
+    goalHandler,
     specsHandler,
     sddBoardHandler,
     sddWizardHandler,
@@ -13991,6 +15607,11 @@ async function startWebUI(opts = {}) {
     onFleetPing: () => {
       void eventArming.getFleetBroadcast()?.();
     },
+    onTechStackEvent: (event) => broadcast(clients, event),
+    // Read through `context` on every call rather than capturing: the running
+    // loop swaps provider/model when the user switches (same live source the
+    // completion handler reads).
+    getLlm: () => context.provider && context.model ? { provider: context.provider, model: context.model } : void 0,
     distDir: opts.distDir
   });
   registerShutdown({
@@ -14020,7 +15641,7 @@ async function startWebUI(opts = {}) {
           archiveLowConfidenceAfterDays: config.superMemory?.hygiene?.archiveLowConfidenceAfterDays
         }).catch((err) => logger.warn(`super-memory session hygiene failed: ${toErrorMessage10(err)}`));
       }
-      await unregisterInstance(process.pid, path22.dirname(globalConfigPath));
+      await unregisterInstance(process.pid, path23.dirname(globalConfigPath));
     }
   });
 }
@@ -14039,8 +15660,8 @@ function createConfigWriteLock() {
     acquire() {
       const prev = lock;
       let release = () => void 0;
-      lock = new Promise((resolve10) => {
-        release = resolve10;
+      lock = new Promise((resolve12) => {
+        release = resolve12;
       });
       return { prev, release };
     }
@@ -14114,8 +15735,8 @@ function createProviderStore(deps2) {
   };
 }
 export {
-  AutoPhaseWebSocketHandler,
   CollaborationWebSocketHandler,
+  GoalWebSocketHandler,
   SKIP_DIRS,
   SURFACE_DEFAULT_PORTS,
   SddBoardWebSocketHandler,
@@ -14150,6 +15771,7 @@ export {
   errMessage,
   estimateContextBreakdown,
   estimateTokens,
+  extractCodeMapFileTargets,
   extractToken,
   extractTokenFromCookie,
   findFreePort,
@@ -14161,7 +15783,6 @@ export {
   handleApiAnalyticsGet,
   handleApiAnalyticsPost,
   handleApiAnalyticsSummary,
-  handleAutoPhaseRoute,
   handleBrainRoute,
   handleCompletionRequest,
   handleDesignList,
@@ -14178,6 +15799,7 @@ export {
   handleGitDiff,
   handleGitInfo,
   handleGoalGet,
+  handleGoalRoute,
   handleMailboxMessages,
   handleMailboxRoute,
   handleMcpAdd,
@@ -14224,9 +15846,13 @@ export {
   handleSkillsUninstall,
   handleSkillsUpdate,
   handleSpecsRoute,
+  handleSuperMemoryBackfillRecoverable,
+  handleSuperMemoryCandidateResolve,
   handleSuperMemoryDelete,
+  handleSuperMemoryForFile,
   handleSuperMemoryGet,
   handleSuperMemoryList,
+  handleSuperMemoryRecover,
   handleSuperMemoryRemember,
   handleSuperMemoryUpdate,
   handleWorklistMessage,
@@ -14248,8 +15874,10 @@ export {
   maskedKey,
   messagePreview,
   messageTokens,
+  normalizeCodeMapFileTarget,
   normalizeKeys,
   openBrowser,
+  paginateKanbanBoards,
   patchConfig,
   persistPrefsToConfig,
   projectSavedProviders,