@wrongstack/webui-server 0.296.2 → 0.296.4

package/dist/server/entry.js

@@ -135,85 +135,85 @@ var ENUM_PREF_KEYS = {
   autoReviewCascadeOn: /* @__PURE__ */ new Set(["off", "critical", "high"]),
   fleetChatVerbosity: /* @__PURE__ */ new Set(["off", "full"])
 };
-function validateModelRuntimeValue(modelRuntime, path28) {
+function validateModelRuntimeValue(modelRuntime, path29) {
   const reasoning = modelRuntime["reasoning"];
   if (reasoning !== void 0) {
-    if (!isRecord(reasoning)) return `${path28}.reasoning must be an object when provided`;
+    if (!isRecord(reasoning)) return `${path29}.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 `${path28}.reasoning.mode must be one of: ${Array.from(REASONING_MODE_VALUES).join(", ")}`;
+      return `${path29}.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 `${path28}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
+      return `${path29}.reasoning.effort must be one of: ${Array.from(REASONING_EFFORT_VALUES).join(", ")}`;
     }
     if (preserve !== void 0 && typeof preserve !== "boolean") {
-      return `${path28}.reasoning.preserve must be a boolean when provided`;
+      return `${path29}.reasoning.preserve must be a boolean when provided`;
     }
   }
   const cache2 = modelRuntime["cache"];
   if (cache2 !== void 0) {
-    if (!isRecord(cache2)) return `${path28}.cache must be an object when provided`;
+    if (!isRecord(cache2)) return `${path29}.cache must be an object when provided`;
     const ttl = cache2["ttl"];
     if (ttl !== void 0 && (typeof ttl !== "string" || !CACHE_TTL_VALUES.has(ttl) || ttl === "default")) {
-      return `${path28}.cache.ttl must be one of: 5m, 1h`;
+      return `${path29}.cache.ttl must be one of: 5m, 1h`;
     }
   }
   const parameters = modelRuntime["parameters"];
   if (parameters !== void 0 && !isRecord(parameters)) {
-    return `${path28}.parameters must be an object when provided`;
+    return `${path29}.parameters must be an object when provided`;
   }
   return null;
 }
-function validateModelBlackoutRule(rule, path28) {
+function validateModelBlackoutRule(rule, path29) {
   const id = rule["id"];
   if (typeof id !== "string" || id.trim().length === 0) {
-    return `${path28}.id must be a non-empty string`;
+    return `${path29}.id must be a non-empty string`;
   }
   const start = rule["start"];
   if (typeof start !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(start)) {
-    return `${path28}.start must be a string in HH:mm (00:00-23:59) format`;
+    return `${path29}.start must be a string in HH:mm (00:00-23:59) format`;
   }
   const end = rule["end"];
   if (typeof end !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(end)) {
-    return `${path28}.end must be a string in HH:mm (00:00-23:59) format`;
+    return `${path29}.end must be a string in HH:mm (00:00-23:59) format`;
   }
   if (rule["enabled"] !== void 0 && typeof rule["enabled"] !== "boolean") {
-    return `${path28}.enabled must be a boolean when provided`;
+    return `${path29}.enabled must be a boolean when provided`;
   }
   if (rule["provider"] !== void 0 && typeof rule["provider"] !== "string") {
-    return `${path28}.provider must be a string when provided`;
+    return `${path29}.provider must be a string when provided`;
   }
   if (rule["model"] !== void 0 && typeof rule["model"] !== "string") {
-    return `${path28}.model must be a string when provided`;
+    return `${path29}.model must be a string when provided`;
   }
   if (rule["days"] !== void 0) {
-    if (!Array.isArray(rule["days"])) return `${path28}.days must be an array when provided`;
+    if (!Array.isArray(rule["days"])) return `${path29}.days must be an array when provided`;
     const seen = /* @__PURE__ */ new Set();
     for (const d of rule["days"]) {
       if (typeof d !== "number" || !Number.isInteger(d) || d < 0 || d > 6) {
-        return `${path28}.days elements must be integers 0-6 when provided`;
+        return `${path29}.days elements must be integers 0-6 when provided`;
       }
-      if (seen.has(d)) return `${path28}.days contains duplicate day: ${d}`;
+      if (seen.has(d)) return `${path29}.days contains duplicate day: ${d}`;
       seen.add(d);
     }
   }
   if (rule["timezone"] !== void 0) {
     if (typeof rule["timezone"] !== "string") {
-      return `${path28}.timezone must be a string when provided`;
+      return `${path29}.timezone must be a string when provided`;
     }
     try {
       Intl.DateTimeFormat(void 0, { timeZone: rule["timezone"] });
     } catch {
-      return `${path28}.timezone is not a valid IANA timezone (e.g. "America/New_York")`;
+      return `${path29}.timezone is not a valid IANA timezone (e.g. "America/New_York")`;
     }
   }
   if (rule["label"] !== void 0 && typeof rule["label"] !== "string") {
-    return `${path28}.label must be a string when provided`;
+    return `${path29}.label must be a string when provided`;
   }
   if (rule["mode"] !== void 0 && rule["mode"] !== "blackout" && rule["mode"] !== "allow_only") {
-    return `${path28}.mode must be 'blackout' or 'allow_only' when provided`;
+    return `${path29}.mode must be 'blackout' or 'allow_only' when provided`;
   }
   return null;
 }
@@ -737,8 +737,8 @@ function validateShellOpenPayload(payload) {
   if (!isRecord2(payload)) {
     return { ok: false, message: "shell.open payload must be an object with string path" };
   }
-  const path28 = payload["path"];
-  if (typeof path28 !== "string" || path28.trim().length === 0) {
+  const path29 = payload["path"];
+  if (typeof path29 !== "string" || path29.trim().length === 0) {
     return { ok: false, message: "shell.open payload.path must be a non-empty string" };
   }
   const target = payload["target"];
@@ -751,7 +751,7 @@ function validateShellOpenPayload(payload) {
   return {
     ok: true,
     value: {
-      path: path28,
+      path: path29,
       ...target !== void 0 ? { target } : {}
     }
   };
@@ -760,14 +760,14 @@ function validateGitDiffPayload(payload) {
   if (!isRecord2(payload)) {
     return { ok: false, message: "git.diff payload must be an object" };
   }
-  const path28 = payload["path"];
-  if (path28 === void 0 || path28 === null) {
+  const path29 = payload["path"];
+  if (path29 === void 0 || path29 === null) {
     return { ok: true, value: { path: "" } };
   }
-  if (typeof path28 !== "string") {
+  if (typeof path29 !== "string") {
     return { ok: false, message: "git.diff payload.path must be a string when provided" };
   }
-  return { ok: true, value: { path: path28 } };
+  return { ok: true, value: { path: path29 } };
 }
 function validateProjectsAddPayload(payload) {
   if (!isRecord2(payload)) {
@@ -4288,8 +4288,8 @@ function jsonByteLength(value) {
     return MAX_PAYLOAD_BYTES + 1;
   }
 }
-function error(errors, path28, code, message) {
-  errors.push({ path: path28, code, message });
+function error(errors, path29, code, message) {
+  errors.push({ path: path29, code, message });
 }
 function isMessageRole(value) {
   return value === "user" || value === "assistant" || value === "system";
@@ -4297,25 +4297,25 @@ function isMessageRole(value) {
 function isPlainJsonObject(value) {
   return isRecord3(value);
 }
-function validateCacheControl(value, path28, errors) {
+function validateCacheControl(value, path29, errors) {
   if (value === void 0) return void 0;
   if (!isRecord3(value) || value["type"] !== "ephemeral") {
-    error(errors, path28, "INVALID_CACHE_CONTROL", 'cache_control must be { type: "ephemeral" }.');
+    error(errors, path29, "INVALID_CACHE_CONTROL", 'cache_control must be { type: "ephemeral" }.');
     return void 0;
   }
   return { type: "ephemeral" };
 }
-function validateProviderMeta(value, path28, errors) {
+function validateProviderMeta(value, path29, errors) {
   if (value === void 0) return void 0;
   if (!isPlainJsonObject(value)) {
-    error(errors, path28, "INVALID_PROVIDER_META", "providerMeta must be a JSON object.");
+    error(errors, path29, "INVALID_PROVIDER_META", "providerMeta must be a JSON object.");
     return void 0;
   }
   return value;
 }
-function validateBlock(value, path28, errors) {
+function validateBlock(value, path29, errors) {
   if (!isRecord3(value)) {
-    error(errors, path28, "INVALID_BLOCK", "Content block must be an object.");
+    error(errors, path29, "INVALID_BLOCK", "Content block must be an object.");
     return void 0;
   }
   const type = value["type"];
@@ -4323,14 +4323,14 @@ function validateBlock(value, path28, errors) {
     case "text": {
       const text = value["text"];
       if (typeof text !== "string") {
-        error(errors, `${path28}/text`, "INVALID_TEXT", "Text block text must be a string.");
+        error(errors, `${path29}/text`, "INVALID_TEXT", "Text block text must be a string.");
         return void 0;
       }
       if (text.length > MAX_STRING_LENGTH) {
-        error(errors, `${path28}/text`, "TEXT_TOO_LARGE", "Text block is too large.");
+        error(errors, `${path29}/text`, "TEXT_TOO_LARGE", "Text block is too large.");
         return void 0;
       }
-      const cacheControl = validateCacheControl(value["cache_control"], `${path28}/cache_control`, errors);
+      const cacheControl = validateCacheControl(value["cache_control"], `${path29}/cache_control`, errors);
       return cacheControl ? { type: "text", text, cache_control: cacheControl } : { type: "text", text };
     }
     case "tool_use": {
@@ -4338,15 +4338,15 @@ function validateBlock(value, path28, errors) {
       const name2 = value["name"];
       const input = value["input"];
       if (typeof id !== "string" || id.length === 0) {
-        error(errors, `${path28}/id`, "INVALID_TOOL_USE_ID", "tool_use.id must be a non-empty string.");
+        error(errors, `${path29}/id`, "INVALID_TOOL_USE_ID", "tool_use.id must be a non-empty string.");
       }
       if (typeof name2 !== "string" || name2.length === 0) {
-        error(errors, `${path28}/name`, "INVALID_TOOL_NAME", "tool_use.name must be a non-empty string.");
+        error(errors, `${path29}/name`, "INVALID_TOOL_NAME", "tool_use.name must be a non-empty string.");
       }
       if (!isPlainJsonObject(input)) {
-        error(errors, `${path28}/input`, "INVALID_TOOL_INPUT", "tool_use.input must be an object.");
+        error(errors, `${path29}/input`, "INVALID_TOOL_INPUT", "tool_use.input must be an object.");
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path28}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(value["providerMeta"], `${path29}/providerMeta`, errors);
       if (typeof id !== "string" || id.length === 0 || typeof name2 !== "string" || name2.length === 0 || !isPlainJsonObject(input)) {
         return void 0;
       }
@@ -4358,18 +4358,18 @@ function validateBlock(value, path28, errors) {
       const content = value["content"];
       const isError = value["is_error"];
       if (typeof toolUseId !== "string" || toolUseId.length === 0) {
-        error(errors, `${path28}/tool_use_id`, "INVALID_TOOL_RESULT_ID", "tool_result.tool_use_id must be a non-empty string.");
+        error(errors, `${path29}/tool_use_id`, "INVALID_TOOL_RESULT_ID", "tool_result.tool_use_id must be a non-empty string.");
       }
       if (name2 !== void 0 && typeof name2 !== "string") {
-        error(errors, `${path28}/name`, "INVALID_TOOL_RESULT_NAME", "tool_result.name must be a string.");
+        error(errors, `${path29}/name`, "INVALID_TOOL_RESULT_NAME", "tool_result.name must be a string.");
       }
       if (typeof content !== "string") {
-        error(errors, `${path28}/content`, "INVALID_TOOL_RESULT_CONTENT", "tool_result.content must be a string.");
+        error(errors, `${path29}/content`, "INVALID_TOOL_RESULT_CONTENT", "tool_result.content must be a string.");
       } else if (content.length > MAX_STRING_LENGTH) {
-        error(errors, `${path28}/content`, "TOOL_RESULT_TOO_LARGE", "tool_result.content is too large.");
+        error(errors, `${path29}/content`, "TOOL_RESULT_TOO_LARGE", "tool_result.content is too large.");
       }
       if (isError !== void 0 && typeof isError !== "boolean") {
-        error(errors, `${path28}/is_error`, "INVALID_TOOL_RESULT_ERROR", "tool_result.is_error must be boolean.");
+        error(errors, `${path29}/is_error`, "INVALID_TOOL_RESULT_ERROR", "tool_result.is_error must be boolean.");
       }
       if (typeof toolUseId !== "string" || toolUseId.length === 0 || typeof content !== "string") return void 0;
       return {
@@ -4383,25 +4383,25 @@ function validateBlock(value, path28, errors) {
     case "image": {
       const source = value["source"];
       if (!isRecord3(source)) {
-        error(errors, `${path28}/source`, "INVALID_IMAGE_SOURCE", "image.source must be an object.");
+        error(errors, `${path29}/source`, "INVALID_IMAGE_SOURCE", "image.source must be an object.");
         return void 0;
       }
       const sourceType = source["type"];
       if (sourceType !== "base64" && sourceType !== "url") {
-        error(errors, `${path28}/source/type`, "INVALID_IMAGE_SOURCE_TYPE", "image.source.type must be base64 or url.");
+        error(errors, `${path29}/source/type`, "INVALID_IMAGE_SOURCE_TYPE", "image.source.type must be base64 or url.");
         return void 0;
       }
       const mediaType = source["media_type"];
       const data = source["data"];
       const url = source["url"];
       if (mediaType !== void 0 && typeof mediaType !== "string") {
-        error(errors, `${path28}/source/media_type`, "INVALID_IMAGE_MEDIA_TYPE", "image.source.media_type must be a string.");
+        error(errors, `${path29}/source/media_type`, "INVALID_IMAGE_MEDIA_TYPE", "image.source.media_type must be a string.");
       }
       if (data !== void 0 && typeof data !== "string") {
-        error(errors, `${path28}/source/data`, "INVALID_IMAGE_DATA", "image.source.data must be a string.");
+        error(errors, `${path29}/source/data`, "INVALID_IMAGE_DATA", "image.source.data must be a string.");
       }
       if (url !== void 0 && typeof url !== "string") {
-        error(errors, `${path28}/source/url`, "INVALID_IMAGE_URL", "image.source.url must be a string.");
+        error(errors, `${path29}/source/url`, "INVALID_IMAGE_URL", "image.source.url must be a string.");
       }
       return {
         type: "image",
@@ -4417,13 +4417,13 @@ function validateBlock(value, path28, errors) {
       const thinking = value["thinking"];
       const signature = value["signature"];
       if (typeof thinking !== "string") {
-        error(errors, `${path28}/thinking`, "INVALID_THINKING", "thinking.thinking must be a string.");
+        error(errors, `${path29}/thinking`, "INVALID_THINKING", "thinking.thinking must be a string.");
         return void 0;
       }
       if (signature !== void 0 && typeof signature !== "string") {
-        error(errors, `${path28}/signature`, "INVALID_THINKING_SIGNATURE", "thinking.signature must be a string.");
+        error(errors, `${path29}/signature`, "INVALID_THINKING_SIGNATURE", "thinking.signature must be a string.");
       }
-      const providerMeta = validateProviderMeta(value["providerMeta"], `${path28}/providerMeta`, errors);
+      const providerMeta = validateProviderMeta(value["providerMeta"], `${path29}/providerMeta`, errors);
       return {
         type: "thinking",
         thinking,
@@ -4432,7 +4432,7 @@ function validateBlock(value, path28, errors) {
       };
     }
     default:
-      error(errors, `${path28}/type`, "UNKNOWN_BLOCK_TYPE", `Unknown content block type: ${String(type)}`);
+      error(errors, `${path29}/type`, "UNKNOWN_BLOCK_TYPE", `Unknown content block type: ${String(type)}`);
       return void 0;
   }
 }
@@ -4450,39 +4450,39 @@ function validateContextEditorMessages(value, currentMessageCount = 0) {
     error(errors, "/messages", "PAYLOAD_TOO_LARGE", "Context editor payload is too large.");
   }
   value.forEach((item, index) => {
-    const path28 = `/messages/${index}`;
+    const path29 = `/messages/${index}`;
     if (!isRecord3(item)) {
-      error(errors, path28, "INVALID_MESSAGE", "Message must be an object.");
+      error(errors, path29, "INVALID_MESSAGE", "Message must be an object.");
       return;
     }
     const role = item["role"];
     if (!isMessageRole(role)) {
-      error(errors, `${path28}/role`, "INVALID_ROLE", "Message role must be user, assistant, or system.");
+      error(errors, `${path29}/role`, "INVALID_ROLE", "Message role must be user, assistant, or system.");
       return;
     }
     const rawContent = item["content"];
     let content;
     if (typeof rawContent === "string") {
       if (rawContent.length > MAX_STRING_LENGTH) {
-        error(errors, `${path28}/content`, "CONTENT_TOO_LARGE", "Message content is too large.");
+        error(errors, `${path29}/content`, "CONTENT_TOO_LARGE", "Message content is too large.");
         return;
       }
       content = rawContent;
     } else if (Array.isArray(rawContent)) {
       const blocks = [];
       rawContent.forEach((block, blockIndex) => {
-        const parsed = validateBlock(block, `${path28}/content/${blockIndex}`, errors);
+        const parsed = validateBlock(block, `${path29}/content/${blockIndex}`, errors);
         if (parsed) blocks.push(parsed);
       });
       content = blocks;
     } else {
-      error(errors, `${path28}/content`, "INVALID_CONTENT", "Message content must be a string or content block array.");
+      error(errors, `${path29}/content`, "INVALID_CONTENT", "Message content must be a string or content block array.");
       return;
     }
     const ts = item["ts"];
     if (ts !== void 0) {
       if (typeof ts !== "string" || Number.isNaN(Date.parse(ts))) {
-        error(errors, `${path28}/ts`, "INVALID_TIMESTAMP", "Message ts must be an ISO-like timestamp string.");
+        error(errors, `${path29}/ts`, "INVALID_TIMESTAMP", "Message ts must be an ISO-like timestamp string.");
         return;
       }
     }
@@ -4856,7 +4856,11 @@ function createConnectionLifecycle(options) {
 }
 
 // src/server/connections-health-route.ts
-import { createChronicleProjectAccess as createChronicleProjectAccess2 } from "@wrongstack/core/chronicle";
+import {
+  ChronicleProjectServerClient,
+  createChronicleProjectAccess as createChronicleProjectAccess2,
+  resolveChronicleProjectServerOptions
+} from "@wrongstack/core/chronicle";
 import {
   isMailboxProjectServerAvailable,
   MailboxProjectServerConnection
@@ -4864,7 +4868,12 @@ import {
 import { resolveWstackPaths as resolveWstackPaths2 } from "@wrongstack/core/utils";
 import { getKanbanServerConnection } from "@wrongstack/kanban";
 import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
-import { checkCodebaseIndexServerHealth, getIndexState } from "@wrongstack/tools";
+import {
+  checkCodebaseIndexServerHealth,
+  getIndexState,
+  resolveProjectIndexDaemonAvailability,
+  shutdownCodebaseIndexServer
+} from "@wrongstack/tools";
 async function handleConnectionsHealthRoute(context, ws, message) {
   if (message.type !== "connections.health") return false;
   try {
@@ -4955,6 +4964,19 @@ async function chronicleHealth(projectRoot) {
 }
 async function codebaseIndexHealth(projectRoot, indexDir) {
   const startedAt = Date.now();
+  const availability = resolveProjectIndexDaemonAvailability(projectRoot, indexDir);
+  if (availability.kind === "endpoint-invalid") {
+    return {
+      id: "codebase-index",
+      label: "Codebase index",
+      status: "unavailable",
+      required: false,
+      mode: "endpoint-invalid",
+      detail: `Socket path is ${availability.byteLength} bytes \u2014 over this platform's ${availability.maxBytes}-byte sun_path limit. Queries fall back to a process-local index. Set a shorter TMPDIR to restore the shared daemon.`,
+      endpoint: availability.endpoint,
+      latencyMs: Date.now() - startedAt
+    };
+  }
   try {
     const health = await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
       timeoutMs: 2e3
@@ -5341,9 +5363,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((resolve14) => {
+    const git = (args) => new Promise((resolve15) => {
       ef("git", args, { cwd, timeout: 3e3 }, (err, stdout) => {
-        resolve14(err ? "" : stdout.trim());
+        resolve15(err ? "" : stdout.trim());
       });
     });
     const [branchRaw, diffRaw, statusRaw, upstreamRaw] = await Promise.all([
@@ -5369,12 +5391,12 @@ async function handleGitInfo(ws, projectRoot) {
 function makeGit(cwd) {
   return async (args) => {
     const { execFile: ef } = await import("node:child_process");
-    return new Promise((resolve14) => {
+    return new Promise((resolve15) => {
       ef(
         "git",
         args,
         { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 * 16 },
-        (err, stdout) => resolve14(err ? "" : stdout)
+        (err, stdout) => resolve15(err ? "" : stdout)
       );
     });
   };
@@ -5398,15 +5420,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 path28 = m[3] ?? "";
-        if (path28 === "") {
+        let path29 = m[3] ?? "";
+        if (path29 === "") {
           i += 1;
-          path28 = parts[i + 1] ?? parts[i] ?? "";
+          path29 = parts[i + 1] ?? parts[i] ?? "";
           i += 1;
         }
-        if (!path28) continue;
-        const prev = counts.get(path28) ?? { added: 0, deleted: 0 };
-        counts.set(path28, { added: prev.added + added, deleted: prev.deleted + deleted });
+        if (!path29) continue;
+        const prev = counts.get(path29) ?? { added: 0, deleted: 0 };
+        counts.set(path29, { added: prev.added + added, deleted: prev.deleted + deleted });
       }
     };
     parseNumstat(unstagedNumstat);
@@ -5418,7 +5440,7 @@ async function handleGitChanges(ws, projectRoot) {
       if (!rec || rec.length < 3) continue;
       const x = rec[0] ?? " ";
       const y = rec[1] ?? " ";
-      const path28 = rec.slice(3);
+      const path29 = rec.slice(3);
       const isRename = x === "R" || x === "C" || y === "R" || y === "C";
       if (isRename) i += 1;
       let status;
@@ -5430,13 +5452,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(path28)?.added ?? 0;
-      let deleted = counts.get(path28)?.deleted ?? 0;
+      let added = counts.get(path29)?.added ?? 0;
+      let deleted = counts.get(path29)?.deleted ?? 0;
       if (status === "?") {
         added = 0;
         deleted = 0;
       }
-      files.push({ path: path28, status, added, deleted, staged });
+      files.push({ path: path29, status, added, deleted, staged });
     }
     send(ws, { type: "git.changes", payload: { files } });
   } catch (err) {
@@ -5447,10 +5469,10 @@ async function handleGitChanges(ws, projectRoot) {
   }
 }
 var MAX_DIFF_BYTES = 2 * 1024 * 1024;
-async function handleGitDiff(ws, projectRoot, path28) {
+async function handleGitDiff(ws, projectRoot, path29) {
   const cwd = projectRoot || void 0;
-  const reply2 = (extra) => send(ws, { type: "git.diff", payload: { path: path28, ...extra } });
-  if (!path28 || path28.includes("\0") || path28.includes("..") || nodePath.isAbsolute(path28)) {
+  const reply2 = (extra) => send(ws, { type: "git.diff", payload: { path: path29, ...extra } });
+  if (!path29 || path29.includes("\0") || path29.includes("..") || nodePath.isAbsolute(path29)) {
     reply2({ oldText: "", newText: "", error: "invalid path" });
     return;
   }
@@ -5458,10 +5480,10 @@ async function handleGitDiff(ws, projectRoot, path28) {
     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:${path28}`]);
+    const oldText = await git(["show", `HEAD:${path29}`]);
     let newText = "";
     try {
-      const abs = cwd ? join15(cwd, path28) : path28;
+      const abs = cwd ? join15(cwd, path29) : path29;
       const buf = await readFile11(abs);
       if (buf.includes(0)) {
         reply2({ oldText: "", newText: "", binary: true });
@@ -5541,7 +5563,7 @@ import { execFile } from "node:child_process";
 var GIT_TIMEOUT_MS = 1e4;
 var GIT_MAX_OUTPUT_BYTES = 1024 * 1024;
 function gitStdout(cwd, args) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     execFile(
       "git",
       [...args],
@@ -5552,7 +5574,7 @@ function gitStdout(cwd, args) {
         timeout: GIT_TIMEOUT_MS,
         maxBuffer: GIT_MAX_OUTPUT_BYTES
       },
-      (error2, stdout) => resolve14(error2 ? null : stdout)
+      (error2, stdout) => resolve15(error2 ? null : stdout)
     );
   });
 }
@@ -5818,13 +5840,13 @@ var GoalWebSocketHandler = class {
         const cwd = env?.cwd ?? this.projectRoot;
         try {
           const { exec } = await import("node:child_process");
-          const result = await new Promise((resolve14) => {
+          const result = await new Promise((resolve15) => {
             exec("npx tsc --noEmit", { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
               if (err && err.code === "ENOENT") {
-                resolve14("[verify] tsc not found \u2014 skipping");
+                resolve15("[verify] tsc not found \u2014 skipping");
                 return;
               }
-              resolve14(stdout + stderr);
+              resolve15(stdout + stderr);
             });
           });
           if (result.includes("[verify]") || result.trim().length === 0) {
@@ -6503,7 +6525,7 @@ function pushEvent(event) {
   }
 }
 function parseBody(req) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve15, reject) => {
     let body = "";
     let bodyBytes = 0;
     let tooLarge = false;
@@ -6523,7 +6545,7 @@ function parseBody(req) {
         return;
       }
       try {
-        resolve14(JSON.parse(body));
+        resolve15(JSON.parse(body));
       } catch {
         reject(new Error("Invalid JSON"));
       }
@@ -6600,7 +6622,7 @@ async function handleApiAnalyticsSummary(res) {
 // src/server/http-server.ts
 import * as fs9 from "node:fs/promises";
 import * as http from "node:http";
-import * as path11 from "node:path";
+import * as path12 from "node:path";
 import * as v8 from "node:v8";
 import { getIndexState as getIndexState2 } from "@wrongstack/tools";
 
@@ -6680,6 +6702,156 @@ async function handleCodemapSymbols(res, deps2, file) {
   );
 }
 
+// src/server/deadcode-handlers.ts
+import * as path10 from "node:path";
+import { runDeadCodeScan } from "@wrongstack/tools/codebase-index";
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+function readJsonBody(req) {
+  return new Promise((resolve15, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > MAX_BODY_BYTES) {
+        req.destroy(new Error("Request body too large"));
+        reject(new Error("Request body exceeds 10 MiB limit"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve15(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", (err) => reject(err));
+  });
+}
+async function handleDeadCodeScan(res, deps2, req) {
+  try {
+    let body = {};
+    const raw = await readJsonBody(req);
+    if (raw) {
+      try {
+        body = JSON.parse(raw);
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON body" }));
+        return;
+      }
+    }
+    const scanIndexDir = body.indexDir ?? deps2.indexDir;
+    if (scanIndexDir) {
+      const resolvedRoot = path10.resolve(deps2.projectRoot);
+      const resolvedIndex = path10.resolve(deps2.projectRoot, scanIndexDir);
+      if (resolvedIndex !== resolvedRoot && !resolvedIndex.startsWith(resolvedRoot + path10.sep)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid indexDir: must be within project root" }));
+        return;
+      }
+    }
+    const result = runDeadCodeScan(deps2.projectRoot, {
+      indexDir: scanIndexDir,
+      userEntryPoints: body.entryPoints
+    });
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(result));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Dead-code scan failed",
+        detail: err instanceof Error ? err.message : String(err)
+      })
+    );
+  }
+}
+function handleDeadCodeActionPlan(res, _deps, req) {
+  return readJsonBody(req).then((raw) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid scan result JSON" }));
+      return;
+    }
+    if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.deadPackages) || !Array.isArray(parsed.deadFiles) || !Array.isArray(parsed.deadSymbols)) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "Invalid scan result: missing or malformed required fields (deadPackages, deadFiles, deadSymbols)"
+        })
+      );
+      return;
+    }
+    const result = parsed;
+    const plan = buildActionPlan(result);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(plan));
+  }).catch((err) => {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        error: "Failed to read request body",
+        detail: err instanceof Error ? err.message : String(err)
+      })
+    );
+  });
+}
+function buildActionPlan(result) {
+  const files = /* @__PURE__ */ new Map();
+  for (const dp of result.deadPackages) {
+    const pseudoFile = {
+      file: `${dp.package}/ (package)`,
+      symbolCount: dp.fileCount,
+      symbols: [`remove package ${dp.package} (${dp.fileCount} files, path: ${dp.path})`],
+      priority: 0
+    };
+    files.set(pseudoFile.file, pseudoFile);
+  }
+  for (const df of result.deadFiles) {
+    const existing = files.get(df.file);
+    if (existing) {
+      if (existing.priority > 1) existing.priority = 1;
+      existing.symbolCount += df.symbolCount;
+      continue;
+    }
+    files.set(df.file, {
+      file: df.file,
+      symbolCount: df.symbolCount,
+      symbols: [`entire file (${df.symbolCount} symbols) is dead`],
+      priority: 1
+    });
+  }
+  const deadInAliveFiles = /* @__PURE__ */ new Map();
+  const deadFileSet = new Set(result.deadFiles.map((df) => df.file));
+  for (const ds of result.deadSymbols) {
+    if (deadFileSet.has(ds.file)) continue;
+    const list = deadInAliveFiles.get(ds.file) ?? [];
+    list.push(`${ds.kind} ${ds.name} (line ${ds.line})`);
+    deadInAliveFiles.set(ds.file, list);
+  }
+  for (const [file, symbols] of deadInAliveFiles) {
+    const existing = files.get(file);
+    if (existing) {
+      existing.symbols.push(...symbols);
+      existing.symbolCount += symbols.length;
+      continue;
+    }
+    files.set(file, {
+      file,
+      symbolCount: symbols.length,
+      symbols,
+      priority: 2
+    });
+  }
+  const sorted = [...files.values()].sort((a, b) => a.priority - b.priority || a.file.localeCompare(b.file));
+  return {
+    summary: `Dead-code scan found ${result.stats.dead} dead symbols across ${result.deadFiles.length} dead files and ${result.deadPackages.length} dead packages. Action plan has ${sorted.length} file group(s) to address.`,
+    files: sorted,
+    totalDeadSymbols: result.stats.dead,
+    totalDeadFiles: result.deadFiles.length,
+    totalDeadPackages: result.deadPackages.length
+  };
+}
+
 // src/server/http-server/api-handlers.ts
 async function handleApiSessions(res, globalRoot) {
   if (!globalRoot) {
@@ -6901,8 +7073,8 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
     res.end(JSON.stringify({ error: String(err) }));
   }
 }
-function readJsonBody(req) {
-  return new Promise((resolve14, reject) => {
+function readJsonBody2(req) {
+  return new Promise((resolve15, reject) => {
     let data = "";
     req.on("data", (chunk) => {
       data += chunk;
@@ -6913,7 +7085,7 @@ function readJsonBody(req) {
     });
     req.on("end", () => {
       try {
-        resolve14(data ? JSON.parse(data) : {});
+        resolve15(data ? JSON.parse(data) : {});
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -6929,7 +7101,7 @@ async function handleApiSessionMessage(res, req, globalRoot, sessionId) {
   }
   let body;
   try {
-    body = await readJsonBody(req);
+    body = await readJsonBody2(req);
   } catch {
     res.writeHead(400, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Invalid request body" }));
@@ -7031,7 +7203,7 @@ async function handleApiSessionInterrupt(res, req, globalRoot, sessionId) {
   }
   let body = {};
   try {
-    body = await readJsonBody(req);
+    body = await readJsonBody2(req);
   } catch {
   }
   const reason = typeof body["reason"] === "string" && body["reason"].trim() ? body["reason"].trim() : "Operator requested stop from Fleet HQ";
@@ -7072,7 +7244,7 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
   }
   let body;
   try {
-    body = await readJsonBody(req);
+    body = await readJsonBody2(req);
   } catch {
     res.writeHead(400, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ error: "Invalid request body" }));
@@ -7136,12 +7308,12 @@ async function handleApiFleetBroadcast(res, req, globalRoot) {
 
 // src/server/projects-manifest.ts
 import * as fs8 from "node:fs/promises";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import { ConfigError } from "@wrongstack/core/types";
 import { projectSlug, withFileLock } from "@wrongstack/core/utils";
 function projectsJsonPath(globalConfigPath) {
-  const base = path10.dirname(globalConfigPath);
-  return path10.join(base, "projects.json");
+  const base = path11.dirname(globalConfigPath);
+  return path11.join(base, "projects.json");
 }
 async function loadManifest(globalConfigPath) {
   try {
@@ -7154,37 +7326,37 @@ async function loadManifest(globalConfigPath) {
 }
 async function saveManifest(manifest, globalConfigPath) {
   const file = projectsJsonPath(globalConfigPath);
-  await fs8.mkdir(path10.dirname(file), { recursive: true });
+  await fs8.mkdir(path11.dirname(file), { recursive: true });
   await fs8.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
 }
 function generateProjectSlug(rootPath) {
   return projectSlug(rootPath);
 }
 async function ensureProjectDataDir(slug, globalConfigPath) {
-  const base = path10.dirname(globalConfigPath);
-  const dir = path10.join(base, "projects", slug);
+  const base = path11.dirname(globalConfigPath);
+  const dir = path11.join(base, "projects", slug);
   await fs8.mkdir(dir, { recursive: true });
   return dir;
 }
 async function touchProjectInManifest(options, globalConfigPath) {
-  const root = path10.resolve(options.projectRoot);
+  const root = path11.resolve(options.projectRoot);
   const file = projectsJsonPath(globalConfigPath);
   let entry;
   await withFileLock(file, async () => {
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    entry = manifest.projects.find((candidate) => path10.resolve(candidate.root) === root);
+    entry = manifest.projects.find((candidate) => path11.resolve(candidate.root) === root);
     if (entry) {
       entry.lastSeen = now;
-      if (options.workingDir) entry.lastWorkingDir = path10.resolve(options.workingDir);
+      if (options.workingDir) entry.lastWorkingDir = path11.resolve(options.workingDir);
     } else {
       entry = {
-        name: options.name ?? path10.basename(root),
+        name: options.name ?? path11.basename(root),
         root,
         slug: generateProjectSlug(root),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: options.workingDir ? path10.resolve(options.workingDir) : void 0
+        lastWorkingDir: options.workingDir ? path11.resolve(options.workingDir) : void 0
       };
       manifest.projects.push(entry);
     }
@@ -7595,9 +7767,9 @@ function buildCspHeader(publicWsUrl, host, port) {
   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 = path11.resolve(distDir);
-  const resolved = path11.resolve(candidate);
-  return resolved === root || resolved.startsWith(root + path11.sep);
+  const root = path12.resolve(distDir);
+  const resolved = path12.resolve(candidate);
+  return resolved === root || resolved.startsWith(root + path12.sep);
 }
 function decodeSessionId(segment) {
   try {
@@ -7617,7 +7789,7 @@ function strictDecodeParam(segment, res) {
 }
 function createHttpServer(opts) {
   const port = opts.port ?? Number.parseInt(process.env["PORT"] ?? "3456", 10);
-  const distDir = path11.resolve(opts.distDir);
+  const distDir = path12.resolve(opts.distDir);
   const requireAccessToken = Boolean(opts.requireToken) || !isLoopbackBind(opts.host);
   let techStackRuntime = null;
   const getTechStackRuntime = async () => {
@@ -7836,6 +8008,42 @@ function createHttpServer(opts) {
         );
         return;
       }
+      if (url.pathname === "/api/deadcode/scan" && req.method === "POST") {
+        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 deadCodeDeps = {
+          projectRoot: opts.projectRoot,
+          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
+        };
+        await handleDeadCodeScan(res, deadCodeDeps, req);
+        return;
+      }
+      if (url.pathname === "/api/deadcode/action-plan" && req.method === "POST") {
+        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 deadCodeDeps = {
+          projectRoot: opts.projectRoot,
+          ...opts.indexDir ? { indexDir: opts.indexDir } : {}
+        };
+        await handleDeadCodeActionPlan(res, deadCodeDeps, req);
+        return;
+      }
       if (url.pathname.startsWith("/api/techstack/")) {
         if (requireAccessToken && !accessTokenOk) {
           res.writeHead(401, { "Content-Type": "application/json" });
@@ -7968,17 +8176,17 @@ function createHttpServer(opts) {
       }
       let filePath;
       if (url.pathname === "/" || url.pathname === "") {
-        filePath = path11.join(distDir, "index.html");
+        filePath = path12.join(distDir, "index.html");
       } else {
-        filePath = path11.join(distDir, url.pathname);
+        filePath = path12.join(distDir, url.pathname);
       }
-      const resolvedPath = path11.resolve(filePath);
+      const resolvedPath = path12.resolve(filePath);
       if (!isInsideDist(resolvedPath, distDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext = path11.extname(resolvedPath);
+      const ext = path12.extname(resolvedPath);
       const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
       res.setHeader("Content-Type", contentType);
       setStaticSecurityHeaders(res);
@@ -8002,7 +8210,7 @@ function createHttpServer(opts) {
     } catch (err) {
       if (err.code === "ENOENT") {
         try {
-          const html = await fs9.readFile(path11.join(distDir, "index.html"), "utf8");
+          const html = await fs9.readFile(path12.join(distDir, "index.html"), "utf8");
           setStaticSecurityHeaders(res);
           res.writeHead(200, {
             "Content-Type": "text/html",
@@ -8032,14 +8240,14 @@ function createHttpServer(opts) {
 
 // src/server/instance-registry.ts
 import * as os from "node:os";
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 import * as fs10 from "node:fs/promises";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core/utils";
 function defaultBaseDir() {
-  return path12.join(os.homedir(), ".wrongstack");
+  return path13.join(os.homedir(), ".wrongstack");
 }
 function registryPath(baseDir = defaultBaseDir()) {
-  return path12.join(baseDir, "webui-instances.json");
+  return path13.join(baseDir, "webui-instances.json");
 }
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return false;
@@ -11402,16 +11610,16 @@ function createModelOperations(context) {
 import * as net from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
 function isPortFree(host, port) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve15) => {
     const srv = net.createServer();
-    srv.once("error", () => resolve14(false));
+    srv.once("error", () => resolve15(false));
     srv.once("listening", () => {
-      srv.close(() => resolve14(true));
+      srv.close(() => resolve15(true));
     });
     try {
       srv.listen(port, host);
     } catch {
-      resolve14(false);
+      resolve15(false);
     }
   });
 }
@@ -11703,7 +11911,7 @@ function seedContextMeta(config, context) {
   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["autoReviewDebounceMs"] = typeof autoReviewExt?.["debounceMs"] === "number" && autoReviewExt["debounceMs"] >= 0 ? autoReviewExt["debounceMs"] : 15e3;
   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"];
@@ -11723,7 +11931,7 @@ function seedContextMeta(config, context) {
 
 // src/server/pref-helpers.ts
 import * as fs12 from "node:fs/promises";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import { decryptConfigSecrets as decryptConfigSecrets2, encryptConfigSecrets } from "@wrongstack/core/security";
 import { atomicWrite as atomicWrite6, backupConfigFile, FORBIDDEN_PROTO_KEYS as FORBIDDEN_PROTO_KEYS2 } from "@wrongstack/core/utils";
 var PREF_KEYS = [
@@ -11819,7 +12027,7 @@ function prefSnapshot(contextMeta) {
   return snapshot;
 }
 async function writeGlobalConfigFile(filePath, vault, mutate, logger, errorLabel) {
-  const globalRoot = path13.dirname(filePath);
+  const globalRoot = path14.dirname(filePath);
   await backupConfigFile(filePath, { globalRoot });
   let raw;
   try {
@@ -12299,7 +12507,7 @@ async function handleProcessRoute(ws, msg, handlers) {
 
 // src/server/project-handlers.ts
 import * as fs13 from "node:fs/promises";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { DefaultSessionStore } from "@wrongstack/core/storage";
 import { resolveWstackPaths as resolveWstackPaths4 } from "@wrongstack/core/utils";
 function createProjectHandlers(ctx) {
@@ -12351,8 +12559,8 @@ function createProjectHandlers(ctx) {
         });
         return;
       }
-      const resolved = path14.resolve(parsed.value.root);
-      const name2 = parsed.value.name?.trim() || path14.basename(resolved);
+      const resolved = path15.resolve(parsed.value.root);
+      const name2 = parsed.value.name?.trim() || path15.basename(resolved);
       try {
         const stat3 = await fs13.stat(resolved).catch(() => null);
         if (!stat3?.isDirectory()) {
@@ -12363,7 +12571,7 @@ function createProjectHandlers(ctx) {
           return;
         }
         const before = await loadManifest(ctx.globalConfigPath);
-        const already = before.projects.some((project) => path14.resolve(project.root) === resolved);
+        const already = before.projects.some((project) => path15.resolve(project.root) === resolved);
         const entry = await touchProjectInManifest(
           { projectRoot: resolved, workingDir: resolved, name: name2 },
           ctx.globalConfigPath
@@ -12393,8 +12601,8 @@ function createProjectHandlers(ctx) {
         });
         return;
       }
-      const resolved = path14.resolve(parsed.value.root);
-      const name2 = parsed.value.name?.trim() || path14.basename(resolved);
+      const resolved = path15.resolve(parsed.value.root);
+      const name2 = parsed.value.name?.trim() || path15.basename(resolved);
       if (!ctx.allowProjectMutations) {
         sendTo(ws, {
           type: "projects.selected",
@@ -12429,6 +12637,17 @@ function createProjectHandlers(ctx) {
         });
         const previous = ctx.getSession();
         const previousId = previous.id;
+        const previousProjectRoot = ctx.getProjectRoot();
+        const previousPaths = resolveWstackPaths4({
+          projectRoot: previousProjectRoot,
+          globalRoot: ctx.wpaths.globalRoot
+        });
+        const previousIdentityTarget = {
+          projectSlug: previousPaths.projectSlug,
+          projectRoot: previousProjectRoot,
+          projectName: path15.basename(previousProjectRoot),
+          workingDir: ctx.context.workingDir
+        };
         const previousUsage = ctx.tokenCounter.total();
         const config = ctx.getConfig?.() ?? ctx.config;
         const next = await store.create({
@@ -12454,7 +12673,16 @@ function createProjectHandlers(ctx) {
         };
         try {
           await ctx.onSessionSwapped?.(next.id, identityTarget);
+          await ctx.onBeforeSessionTodosReplaced?.(next.id, paths.projectSessions);
         } catch (err) {
+          try {
+            await ctx.onBeforeSessionTodosReplaced?.(previous.id, previousPaths.projectSessions);
+          } catch {
+          }
+          try {
+            await ctx.onSessionSwapped?.(previous.id, previousIdentityTarget);
+          } catch {
+          }
           await next.close().catch(() => void 0);
           await store.delete(next.id).catch(() => void 0);
           throw err;
@@ -13477,6 +13705,7 @@ var CLIENT_WORKSPACE_MESSAGE_TYPES = [
 var CLIENT_CONFIGURATION_MESSAGE_TYPES = [
   "codebase.index.server.shutdown",
   "connections.health",
+  "connections.service_action",
   "diag.get",
   "key.add",
   "key.delete",
@@ -13750,6 +13979,7 @@ var SERVER_CONFIGURATION_MESSAGE_TYPES = [
   "codebase.index.server.shutdown_result",
   "connections.health_error",
   "connections.health_result",
+  "connections.service_action_result",
   "diag.get",
   "key.operation_result",
   "model.switch_result",
@@ -13794,13 +14024,13 @@ function isRegisteredMessageType(type, direction) {
 // src/protocol/decoder.ts
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 var MAX_PAYLOAD_DEPTH = 32;
-function inspectValue(value, path28, depth) {
+function inspectValue(value, path29, depth) {
   if (depth > MAX_PAYLOAD_DEPTH) {
-    return { code: "too_deep", message: "Protocol payload exceeds the nesting limit", path: path28 };
+    return { code: "too_deep", message: "Protocol payload exceeds the nesting limit", path: path29 };
   }
   if (value === null || typeof value !== "object") return null;
   for (const key of Object.keys(value)) {
-    const childPath = `${path28}.${key}`;
+    const childPath = `${path29}.${key}`;
     if (FORBIDDEN_KEYS.has(key)) {
       return { code: "unsafe_key", message: `Unsafe protocol key: ${key}`, path: childPath };
     }
@@ -14010,6 +14240,7 @@ function createSessionHandlers(ctx) {
     ctx.context.session = next;
     ctx.context.state.replaceMessages(messages);
     await ctx.context.flushConversationJournal?.();
+    await ctx.onBeforeSessionTodosReplaced?.(next.id, sessionsDirectory());
     ctx.context.state.replaceTodos(todos);
     resetContextAccounting();
     ctx.context.readFiles.clear();
@@ -14406,7 +14637,10 @@ function createSessionHandlers(ctx) {
         rollbackClaim = await ctx.claimSession?.(canonicalId);
         const resumed = await store.resume(canonicalId);
         const restoredTodos = await loadTodosCheckpoint(
-          sessionScopedPath(sessionsDirectory(), resumed.writer.id, ".todos.json")
+          sessionScopedPath(sessionsDirectory(), resumed.writer.id, ".todos.json"),
+          ctx.events,
+          ctx.context.traceId,
+          resumed.writer.id
         ).catch(() => null) ?? [];
         activated = true;
         await activateSession(
@@ -14925,7 +15159,7 @@ ${String(p.content ?? "")}`;
 };
 
 // src/server/codebase-index-server-control.ts
-import { shutdownCodebaseIndexServer } from "@wrongstack/tools";
+import { shutdownCodebaseIndexServer as shutdownCodebaseIndexServer2 } from "@wrongstack/tools";
 async function handleCodebaseIndexServerControl(ws, message, deps2) {
   if (message.type !== "codebase.index.server.shutdown") return false;
   const requestId = message.payload && typeof message.payload === "object" && typeof message.payload.requestId === "string" ? message.payload.requestId : "";
@@ -14952,7 +15186,7 @@ async function handleCodebaseIndexServerControl(ws, message, deps2) {
     });
     return true;
   }
-  const result = await shutdownCodebaseIndexServer(
+  const result = await shutdownCodebaseIndexServer2(
     projectRoot,
     deps2.getIndexDir(),
     "websocket-request"
@@ -15493,7 +15727,7 @@ function createRouteFamilyDispatcher(options) {
 
 // src/server/shell-open.ts
 import * as fs15 from "node:fs/promises";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 import { spawn } from "node:child_process";
 function normalizeShellOpenTarget(target) {
   return target === "terminal" ? "terminal" : "file-manager";
@@ -15504,11 +15738,11 @@ function shellQuote(s) {
 }
 async function handleShellOpen(req, logger, options) {
   try {
-    const resolved = path15.resolve(req.path);
+    const resolved = path16.resolve(req.path);
     if (options?.projectRoot) {
-      const root = path15.resolve(options.projectRoot);
-      const relative5 = path15.relative(root, resolved);
-      const escapes = relative5.startsWith("..") || path15.isAbsolute(relative5);
+      const root = path16.resolve(options.projectRoot);
+      const relative5 = path16.relative(root, resolved);
+      const escapes = relative5.startsWith("..") || path16.isAbsolute(relative5);
       if (escapes) {
         return {
           success: false,
@@ -15570,6 +15804,7 @@ async function handleShellOpen(req, logger, options) {
 import { listBoards as listBoards3 } from "@wrongstack/kanban";
 import {
   applySddLifecycle,
+  extractVerificationCommand,
   SddBoardStore
 } from "@wrongstack/sdd";
 var CONTROL_TYPES = /* @__PURE__ */ new Set([
@@ -15592,14 +15827,16 @@ var SddBoardWebSocketHandler = class {
   store;
   clients = /* @__PURE__ */ new Set();
   lifecycle;
+  security;
   diskPollingEnabled;
   latest = null;
   poll = null;
   pollInFlight = false;
   unsub = null;
-  constructor(boardsDir, events, lifecycle) {
+  constructor(boardsDir, events, lifecycle, security) {
     this.store = new SddBoardStore({ baseDir: boardsDir });
     this.lifecycle = lifecycle;
+    this.security = security;
     this.diskPollingEnabled = events === void 0;
     if (events) {
       const handler = (e) => {
@@ -15645,6 +15882,43 @@ var SddBoardWebSocketHandler = class {
       return;
     }
     if (CONTROL_TYPES.has(action)) {
+      const verificationCommands = [];
+      if (action === "set_task_verification") {
+        const command = msg.payload?.verificationCommand;
+        if (command !== void 0 && (typeof command !== "string" || command.length > 8192)) return;
+        if (typeof command === "string" && command.trim()) {
+          verificationCommands.push({ command, operation: "sdd.set_task_verification" });
+        }
+      } else if (action === "split_task") {
+        const subtasks = msg.payload?.subtasks;
+        if (Array.isArray(subtasks)) {
+          for (const subtask of subtasks) {
+            if (!subtask || typeof subtask !== "object") continue;
+            const criterion = subtask.successCriterion;
+            if (criterion === void 0) continue;
+            if (typeof criterion !== "string") return;
+            const command = extractVerificationCommand([criterion]);
+            if (!command) continue;
+            if (command.length > 8192) return;
+            verificationCommands.push({ command, operation: "sdd.split_task_verification" });
+          }
+        }
+      }
+      for (const { command, operation } of verificationCommands) {
+        if (!this.security) return;
+        const authorization = await authorizeWebUIAction(
+          this.security.trustBoundary,
+          {
+            capability: "process.spawn",
+            subject: { kind: "command", id: command },
+            risk: "high",
+            cwd: this.lifecycle?.projectRoot,
+            metadata: { operation }
+          },
+          this.security.logger
+        );
+        if (!authorization.allowed) return;
+      }
       const runId = msg.payload?.runId ?? this.latest?.runId ?? (await this.store.list())[0]?.runId;
       if (runId) {
         await this.store.appendControl(runId, {
@@ -15757,7 +16031,7 @@ var SddBoardWebSocketHandler = class {
 };
 
 // src/server/sdd-wizard-wiring.ts
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import {
   DefaultTaskStore,
   TaskTracker
@@ -15871,7 +16145,7 @@ function buildSddWizardDeps(opts) {
   }).catch(() => {
     projectContext = "";
   });
-  const sessionPath = opts.paths.projectSddSession ?? path16.join(opts.paths.projectDir, "sdd-session.json");
+  const sessionPath = opts.paths.projectSddSession ?? path17.join(opts.paths.projectDir, "sdd-session.json");
   const specStore = new SpecStore({ baseDir: opts.paths.projectSpecs });
   const graphStore = new TaskGraphStore({ baseDir: opts.paths.projectTaskGraphs });
   const runIsolatedTurn = async (prompt, name2) => {
@@ -16153,7 +16427,7 @@ var SddWizardWebSocketHandler = class {
       return;
     }
     const { runId } = await this.deps.startRun(this.driver, opts);
-    this.driver.setLastRunId(runId);
+    await this.driver.setLastRunId(runId);
     if (this.driver.phase() !== "executing" && this.driver.phase() !== "done") {
       try {
         if (this.driver.phase() === "task_review") await this.driver.approve();
@@ -16212,7 +16486,7 @@ var SddWizardWebSocketHandler = class {
       this.lastAgentText = text;
       if (this.driver) {
         await this.driver.ingestAgentOutput(text);
-        this.driver.setLastAgentText(text);
+        await this.driver.setLastAgentText(text);
       }
       this.broadcast({ type: "sdd.spec.agent_text", payload: { text } });
     } finally {
@@ -16243,10 +16517,10 @@ import { recordTaskFileActivity } from "@wrongstack/kanban";
 
 // src/server/setup-events-fleet-broadcaster.ts
 import { watch as fsWatch } from "node:fs";
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 function registerSetupEventsFleetBroadcaster(deps2) {
   const { globalConfigPath, wpaths, context, clients, broadcast: broadcast2, onFleetBroadcaster, isDisposed } = deps2;
-  const globalRoot = globalConfigPath ? path17.dirname(globalConfigPath) : void 0;
+  const globalRoot = globalConfigPath ? path18.dirname(globalConfigPath) : void 0;
   if (!globalRoot) return void 0;
   const disposers = [];
   const broadcastSessions = async () => {
@@ -16256,8 +16530,8 @@ function registerSetupEventsFleetBroadcaster(deps2) {
       const sessions = await registry.list();
       const ownEntry = sessions.find((s) => s.pid === process.pid);
       const mySlug = ownEntry?.projectSlug ?? wpaths?.projectSlug;
-      const myRoot = path17.resolve(context.projectRoot);
-      const live = sessions.filter((s) => s.status === "active" || s.status === "idle").filter((s) => mySlug ? s.projectSlug === mySlug : path17.resolve(s.projectRoot) === myRoot).map((s) => ({
+      const myRoot = path18.resolve(context.projectRoot);
+      const live = sessions.filter((s) => s.status === "active" || s.status === "idle").filter((s) => mySlug ? s.projectSlug === mySlug : path18.resolve(s.projectRoot) === myRoot).map((s) => ({
         sessionId: s.sessionId,
         projectName: s.projectName,
         projectSlug: s.projectSlug,
@@ -16448,13 +16722,13 @@ function createSetupEventSessionHelpers(context, sessionBridge) {
 // src/server/setup-events-status-watcher.ts
 import { watch as fsWatch2 } from "node:fs";
 import * as fs16 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 
 // src/server/setup-events-watcher.ts
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 function statusProjectHashFromWatchFilename(projectsDir, filename) {
   const raw = String(filename);
-  const relative5 = path18.isAbsolute(raw) ? path18.relative(projectsDir, raw) : raw;
+  const relative5 = path19.isAbsolute(raw) ? path19.relative(projectsDir, raw) : raw;
   const parts = relative5.split(/[\\/]+/).filter(Boolean);
   if (parts.length < 2 || parts.at(-1) !== "status.json") return null;
   return parts.at(-2) ?? null;
@@ -16489,7 +16763,7 @@ function logFileWatcherMetrics(metrics) {
 function registerSetupEventsStatusWatcher(deps2) {
   const { wpaths, watcherMetrics, clients, broadcast: broadcast2, on, isDisposed } = deps2;
   if (!wpaths?.projectStatus || !wpaths.globalRoot) return void 0;
-  const projectsDir = path19.join(wpaths.globalRoot, "projects");
+  const projectsDir = path20.join(wpaths.globalRoot, "projects");
   const knownProjectHashes = /* @__PURE__ */ new Set();
   const debounceTimers = /* @__PURE__ */ new Map();
   const DEBOUNCE_MS = 150;
@@ -16548,7 +16822,7 @@ function registerSetupEventsStatusWatcher(deps2) {
           if (!knownProjectHashes.has(projectHash)) return;
           if (watcherMetrics) watcherMetrics.filesProcessed++;
           try {
-            const targetFile = path19.join(projectsDir, projectHash, "status.json");
+            const targetFile = path20.join(projectsDir, projectHash, "status.json");
             const content = await fs16.readFile(targetFile, "utf-8");
             const statusData = JSON.parse(content);
             scheduleBroadcast(projectHash, statusData);
@@ -16607,7 +16881,7 @@ function registerSetupEventsStatusWatcher(deps2) {
 
 // src/server/setup-events-core-watchers.ts
 import * as fs17 from "node:fs/promises";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 function registerSetupEventsCoreWatchers(deps2) {
   const { broadcast: broadcast2, clients, context } = deps2;
   const disposers = [];
@@ -16643,7 +16917,7 @@ function registerSetupEventsClientStatusWriter(deps2) {
     if (wpaths?.projectStatus) {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
-        const dir = path20.dirname(statusFile);
+        const dir = path21.dirname(statusFile);
         await fs17.mkdir(dir, { recursive: true });
         await fs17.writeFile(statusFile, JSON.stringify(e, null, 2), "utf-8");
       } catch (err) {
@@ -16833,6 +17107,9 @@ function setupEvents(deps2) {
         input: scrub(e.input),
         fileTargets: extractCodeMapFileTargets(projectRoot || ".", e.name, e.input),
         output: scrub(e.output),
+        // SAGE-injected memory rides beside the tool text so the client renders
+        // it as a memory card. Never folded back into `output`.
+        ...e.sage && e.sage.length > 0 ? { sage: e.sage.map((line) => scrub(line)) } : {},
         outputBytes: e.outputBytes,
         outputTokens: e.outputTokens,
         outputLines: e.outputLines,
@@ -17667,17 +17944,24 @@ var SpecsWebSocketHandler = class {
 // src/server/start-webui.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import * as http2 from "node:http";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 import { createDefaultPipelines } from "@wrongstack/core/agent";
 import { getSharedProjectMailbox as getSharedProjectMailbox4, resolveProjectDir as resolveProjectDir3 } from "@wrongstack/core/coordination";
 import { createCompatibilityTrustBoundary as createCompatibilityTrustBoundary3 } from "@wrongstack/core/security";
 import {
+  attachTodosCheckpoint,
   createSessionEventBridge,
   resolveSessionLoggingConfig,
   watchProviderConfig
 } from "@wrongstack/core/storage";
 import { DEFAULT_CONTEXT_WINDOW_MODE_ID as DEFAULT_CONTEXT_WINDOW_MODE_ID2 } from "@wrongstack/core/types";
-import { expectDefined as expectDefined3, startHeapWatchdog, toErrorMessage as toErrorMessage13, wstackGlobalRoot as wstackGlobalRoot2 } from "@wrongstack/core/utils";
+import {
+  expectDefined as expectDefined3,
+  sessionScopedPath as sessionScopedPath3,
+  startHeapWatchdog,
+  toErrorMessage as toErrorMessage13,
+  wstackGlobalRoot as wstackGlobalRoot2
+} from "@wrongstack/core/utils";
 import { makeProviderFromConfig as makeProviderFromConfig3 } from "@wrongstack/providers";
 import { toLanguagePackageInput } from "@wrongstack/techstack";
 import { ensureSessionShell } from "@wrongstack/tools";
@@ -17864,7 +18148,7 @@ function findWorkspaceCliEntry(projectRoot) {
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve14) => setTimeout(resolve14, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 
 // src/server/terminal-ws-handler.ts
@@ -18100,7 +18384,7 @@ function clampDim(value, fallback) {
 }
 
 // src/server/worktree-ws-handler.ts
-import { join as join11, resolve as resolve11, sep as sep4 } from "node:path";
+import { join as join11, resolve as resolve12, sep as sep5 } from "node:path";
 import { WorktreeManager as WorktreeManager3 } from "@wrongstack/core/worktree";
 import { cleanupStaleSddWorktrees as cleanupStaleSddWorktrees2 } from "@wrongstack/sdd";
 import { toErrorMessage as toErrorMessage8 } from "@wrongstack/core/utils";
@@ -18161,13 +18445,13 @@ var WorktreeWebSocketHandler = class {
   // ── orphan management ─────────────────────────────────────────────────────
   /** Absolute managed-worktrees root for this project. */
   worktreesRoot() {
-    return resolve11(join11(this.management.projectRoot, ".wrongstack", "worktrees"));
+    return resolve12(join11(this.management.projectRoot, ".wrongstack", "worktrees"));
   }
   /** True iff `dir` resolves strictly inside the managed worktrees root. */
   underRoot(dir) {
-    const abs = resolve11(dir);
+    const abs = resolve12(dir);
     const root = this.worktreesRoot();
-    return abs !== root && abs.startsWith(root + sep4);
+    return abs !== root && abs.startsWith(root + sep5);
   }
   /** Branches of worktrees a live in-session run currently owns. */
   liveActiveBranches() {
@@ -18315,7 +18599,7 @@ var WorktreeWebSocketHandler = class {
     }
     const base = baseBranch && MANAGED_BRANCH_RE.test(baseBranch) ? baseBranch : void 0;
     const wt = new WorktreeManager3({ projectRoot: this.management.projectRoot });
-    const summary = await wt.diffSummary(resolve11(dir), base);
+    const summary = await wt.diffSummary(resolve12(dir), base);
     this.broadcast({ type: "worktree.diff_result", payload: { dir, summary } });
   }
   // ── internals ───────────────────────────────────────────────────────────
@@ -18464,7 +18748,9 @@ async function createAgentServices(input) {
           memory: memoryRetrieval,
           maxHintsPerTool: config.Sage?.inject?.maxHintsPerTool,
           maxCharsPerTool: config.Sage?.inject?.maxCharsPerTool,
+          taskAware: config.Sage?.inject?.taskAware,
           minScore: config.Sage?.inject?.minScore,
+          minImportance: config.Sage?.inject?.minImportance,
           repeatCooldownMs: config.Sage?.inject?.repeatCooldownMs,
           verifyOnMutation: config.Sage?.hygiene?.autoOnFileChange,
           triggers: config.Sage?.inject?.triggers
@@ -18767,15 +19053,20 @@ async function createAgentServices(input) {
     projectRoot
   );
   const specsHandler = new SpecsWebSocketHandler(wpaths.projectSpecs, wpaths.projectTaskGraphs);
-  const sddBoardHandler = new SddBoardWebSocketHandler(wpaths.projectSddBoards, void 0, {
-    projectRoot,
-    paths: {
-      projectSpecs: wpaths.projectSpecs,
-      projectTaskGraphs: wpaths.projectTaskGraphs,
-      projectSddSession: wpaths.projectSddSession,
-      projectSddBoards: wpaths.projectSddBoards
-    }
-  });
+  const sddBoardHandler = new SddBoardWebSocketHandler(
+    wpaths.projectSddBoards,
+    void 0,
+    {
+      projectRoot,
+      paths: {
+        projectSpecs: wpaths.projectSpecs,
+        projectTaskGraphs: wpaths.projectTaskGraphs,
+        projectSddSession: wpaths.projectSddSession,
+        projectSddBoards: wpaths.projectSddBoards
+      }
+    },
+    { trustBoundary: input.trustBoundary, logger }
+  );
   const sddWizardHandler = new SddWizardWebSocketHandler(
     buildSddWizardDeps({
       agent,
@@ -18787,7 +19078,16 @@ async function createAgentServices(input) {
         providerRegistry,
         toolRegistry,
         session: input.sessionGetter(),
-        projectRoot
+        projectRoot,
+        // Thread the container-provided ProviderModelStatusTracker so a 429
+        // from this subagent's first call transitions the (provider, model)
+        // pair to `state: 'blocked'` instead of silently no-op'ing. The
+        // runtime container binds a default `ProviderModelStatusTracker`
+        // (see packages/runtime/src/container.ts); without this dep, the
+        // subagent's fallback extension's tracker hooks are undefined and
+        // round-robin keeps reassigning the doomed model. Mirrors the CLI
+        // factory wiring at host-subagent-factory.ts:337.
+        statusTracker: container.safeResolve(TOKENS.ProviderModelStatusTracker)
       }),
       paths: {
         projectSpecs: wpaths.projectSpecs,
@@ -18930,7 +19230,7 @@ function createConnectionHandler(options) {
 }
 
 // src/server/message-dispatcher.ts
-import path21 from "node:path";
+import path22 from "node:path";
 function createMessageDispatcher(opts) {
   const { state, deps: deps2, routes, promptsCtx, codebaseIndexing, runLock, pendingConfirms } = opts;
   function makeWorklistContext() {
@@ -18951,7 +19251,7 @@ function createMessageDispatcher(opts) {
       skillLoader: deps2.skillLoader,
       skillInstaller: deps2.skillInstaller,
       projectRoot,
-      projectSkillsDir: path21.join(projectRoot, ".wrongstack", "skills"),
+      projectSkillsDir: path22.join(projectRoot, ".wrongstack", "skills"),
       globalSkillsDir: deps2.wpaths.globalSkills
     };
   }
@@ -19203,7 +19503,7 @@ function createMessageDispatcher(opts) {
 
 // src/server/pre-context-services.ts
 import { createRequire as createRequire3 } from "node:module";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import { Context, DefaultSystemPromptBuilder } from "@wrongstack/core/agent";
 import {
   getSharedProjectMailbox as getSharedProjectMailbox3,
@@ -19258,7 +19558,7 @@ import { attachSessionKanbanMirror, hydrateSessionKanban } from "@wrongstack/too
 
 // src/server/model-auto-discovery.ts
 import * as fs18 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { COMPATIBLE_PRESETS, discoverOpenAICompatibleModels } from "@wrongstack/providers";
 function isOverlayRegistry(value) {
   return !!value && typeof value === "object" && typeof value.mergeOverlay === "function";
@@ -19294,7 +19594,7 @@ async function discoverAndMergeWebuiProviders(opts) {
   if (!isOverlayRegistry(registry)) return;
   const targets = eligibleProviders(opts.config);
   if (targets.length === 0) return;
-  const cacheFile = path22.join(opts.cacheDir, "discovered-models-cache.json");
+  const cacheFile = path23.join(opts.cacheDir, "discovered-models-cache.json");
   const cache2 = await readCache(cacheFile);
   let cacheDirty = false;
   await Promise.all(
@@ -19331,7 +19631,7 @@ async function discoverAndMergeWebuiProviders(opts) {
   );
   if (cacheDirty) {
     try {
-      await fs18.mkdir(path22.dirname(cacheFile), { recursive: true });
+      await fs18.mkdir(path23.dirname(cacheFile), { recursive: true });
       await fs18.writeFile(cacheFile, JSON.stringify(cache2), "utf8");
     } catch {
       opts.logger?.debug?.("provider auto-discovery cache write failed");
@@ -19428,7 +19728,7 @@ function resolveSetupProvider(opts) {
 }
 
 // src/server/standalone-session-identity.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 import {
   AgentStatusTracker,
   FleetNotifier,
@@ -19447,7 +19747,7 @@ async function createStandaloneSessionIdentityLifecycle(opts) {
   let activeTarget = {
     projectSlug: paths.projectSlug,
     projectRoot: paths.projectRoot,
-    projectName: path23.basename(paths.projectRoot),
+    projectName: path24.basename(paths.projectRoot),
     workingDir: opts.workingDir
   };
   let pendingClaim;
@@ -19678,7 +19978,7 @@ async function createPreContextServices(input) {
     await discoverAndMergeWebuiProviders({
       config,
       registry: modelsRegistry,
-      cacheDir: path24.dirname(wpaths.modelsCache),
+      cacheDir: path25.dirname(wpaths.modelsCache),
       logger
     });
   } catch (err) {
@@ -19730,7 +20030,7 @@ async function createPreContextServices(input) {
   configureChildEnvGitIdentity(config.git?.identity ?? null);
   console.log("[WebUI] Tool registry loaded:", toolRegistry.list().length, "tools");
   const mcpTokenStore = new MCPVaultTokenStore(
-    path24.join(wpaths.projectDir, "mcp-auth.json"),
+    path25.join(wpaths.projectDir, "mcp-auth.json"),
     vault
   );
   const mcpAuthorizationManager = new MCPAuthorizationManager({ store: mcpTokenStore });
@@ -19836,7 +20136,7 @@ async function createPreContextServices(input) {
   };
   const skillLoader = config.features.skills ? new DefaultSkillLoader({ paths: wpaths }) : void 0;
   const skillInstaller = config.features.skills ? new SkillInstaller({
-    manifestPath: path24.join(wpaths.configDir, "installed-skills.json"),
+    manifestPath: path25.join(wpaths.configDir, "installed-skills.json"),
     projectSkillsDir: wpaths.inProjectSkills,
     globalSkillsDir: wpaths.globalSkills,
     projectHash: wpaths.projectHash,
@@ -19846,8 +20146,8 @@ async function createPreContextServices(input) {
   const bundledPromptsDir = promptsEnabled ? (() => {
     try {
       const req = createRequire3(import.meta.url);
-      return path24.join(
-        path24.dirname(req.resolve("@wrongstack/core/package.json")),
+      return path25.join(
+        path25.dirname(req.resolve("@wrongstack/core/package.json")),
         "data",
         "prompts"
       );
@@ -19951,7 +20251,7 @@ async function createPreContextServices(input) {
 }
 
 // src/server/routes.ts
-import path25 from "node:path";
+import path26 from "node:path";
 import { makeProviderFromConfig as makeProviderFromConfig2, withCatalogCapabilities } from "@wrongstack/providers";
 
 // src/server/mode-handlers.ts
@@ -20076,6 +20376,7 @@ function buildRoutes(state, deps2, cb) {
     config: state.getConfig(),
     clients: state.getClients(),
     context: deps2.context,
+    events: deps2.events,
     toolRegistry: deps2.toolRegistry,
     compactor: deps2.compactor,
     customModeStore: deps2.customModeStore,
@@ -20087,6 +20388,7 @@ function buildRoutes(state, deps2, cb) {
     setSession: state.setSession,
     setSessionStartedAt: state.setSessionStartedAt,
     claimSession: cb.claimSession,
+    onBeforeSessionTodosReplaced: cb.onBeforeSessionTodosReplaced,
     onSessionSwapped: cb.onSessionSwapped,
     abortActiveRun: state.abortRunLock,
     isRunActive: state.isRunActive,
@@ -20108,6 +20410,8 @@ function buildRoutes(state, deps2, cb) {
     setSessionStore: state.setSessionStore,
     setSessionStartedAt: state.setSessionStartedAt,
     abortRunLock: state.abortRunLock,
+    onBeforeSessionTodosReplaced: cb.onBeforeSessionTodosReplaced,
+    onSessionSwapped: cb.onSessionSwapped,
     sessionStartPayload: cb.sessionStartPayload
   });
   const modeRoutes = createModeHandlers({
@@ -20239,7 +20543,7 @@ function buildRoutes(state, deps2, cb) {
   };
   const mailboxRoutes = createMailboxRouteHandlers({
     getProjectRoot: state.getProjectRoot,
-    getGlobalRoot: () => path25.dirname(deps2.globalConfigPath),
+    getGlobalRoot: () => path26.dirname(deps2.globalConfigPath),
     events: deps2.events
   });
   const mcpRoutes = {
@@ -20312,7 +20616,7 @@ function buildRoutes(state, deps2, cb) {
 }
 
 // src/server/server-runtime.ts
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { fileURLToPath } from "node:url";
 import { WebSocketServer } from "ws";
@@ -20373,7 +20677,7 @@ function createSessionStartPayload(g) {
       inputCost,
       outputCost,
       cacheReadCost,
-      projectName: path26.basename(projectRoot) || projectRoot,
+      projectName: path27.basename(projectRoot) || projectRoot,
       projectRoot,
       cwd: g.getWorkingDir(),
       mode: g.getModeId(),
@@ -20461,13 +20765,13 @@ function armEvents(wssPrimary, wssSecondary, wsHost, httpPort, setupInput, watch
   };
 }
 function resolveWebuiDistDir(fromUrl, explicitDistDir) {
-  if (explicitDistDir) return path26.resolve(explicitDistDir);
+  if (explicitDistDir) return path27.resolve(explicitDistDir);
   try {
     const requireFromHere2 = createRequire4(fromUrl);
     const serverEntry = requireFromHere2.resolve("@wrongstack/webui");
-    return path26.dirname(serverEntry);
+    return path27.dirname(serverEntry);
   } catch {
-    return path26.resolve(path26.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
+    return path27.resolve(path27.dirname(fileURLToPath(fromUrl)), "..", "..", "dist");
   }
 }
 function startHttpServer(opts) {
@@ -20498,6 +20802,56 @@ function registerShutdown(deps2) {
 }
 
 // src/server/start-webui.ts
+function createStandaloneTodosCheckpointLifecycle(input) {
+  let checkpointSessionId = input.sessionId;
+  let checkpointSessionsDir = input.sessionsDir;
+  const attachCheckpoint = (sessionId, sessionsDir) => attachTodosCheckpoint(
+    input.state,
+    sessionScopedPath3(sessionsDir, sessionId, ".todos.json"),
+    sessionId,
+    input.events,
+    input.traceId,
+    input.warn
+  );
+  let detachCurrent = attachCheckpoint(input.sessionId, input.sessionsDir);
+  let checkpointAttached = true;
+  const detachCurrentCheckpoint = async () => {
+    if (!checkpointAttached) return;
+    checkpointAttached = false;
+    await detachCurrent();
+  };
+  let transitionTail = Promise.resolve();
+  const rebind = (nextSessionId, sessionsDir) => {
+    const transition = transitionTail.then(async () => {
+      if (checkpointAttached && nextSessionId === checkpointSessionId && sessionsDir === checkpointSessionsDir) {
+        return;
+      }
+      let detachFailed = false;
+      let detachError;
+      try {
+        await detachCurrentCheckpoint();
+      } catch (error2) {
+        detachFailed = true;
+        detachError = error2;
+      }
+      const nextDetach = attachCheckpoint(nextSessionId, sessionsDir);
+      checkpointSessionId = nextSessionId;
+      checkpointSessionsDir = sessionsDir;
+      detachCurrent = nextDetach;
+      checkpointAttached = true;
+      if (detachFailed) throw detachError;
+    });
+    transitionTail = transition.catch(() => void 0);
+    return transition;
+  };
+  return {
+    rebind,
+    detach: async () => {
+      await transitionTail;
+      await detachCurrentCheckpoint();
+    }
+  };
+}
 async function startWebUI(opts = {}) {
   ensureSessionShell();
   const ports = await resolvePorts(opts);
@@ -20565,6 +20919,14 @@ async function startWebUI(opts = {}) {
   } = preContext;
   let sessionStore = preContext.sessionStore;
   let session = preContext.session;
+  const todosCheckpoint = createStandaloneTodosCheckpointLifecycle({
+    state: context.state,
+    sessionsDir: wpaths.projectSessions,
+    sessionId: session.id,
+    events,
+    traceId: context.traceId,
+    warn: (message) => logger.warn(message)
+  });
   let sessionStartedAt = preContext.sessionStartedAt;
   let modeId = preContext.modeId;
   const needsSetup = preContext.needsSetup;
@@ -20691,7 +21053,7 @@ async function startWebUI(opts = {}) {
         if (events.listenerCount("tool.confirm_needed") === 0) {
           throw new Error("No permission confirmation surface is connected");
         }
-        const decision = await new Promise((resolve14) => {
+        const decision = await new Promise((resolve15) => {
           events.emit("tool.confirm_needed", {
             sessionId: context.session.id,
             tool: confirmTool,
@@ -20701,7 +21063,7 @@ async function startWebUI(opts = {}) {
             decisionSource: pending.decisionSource,
             riskTier: pending.riskTier,
             boundaryReason: pending.boundaryReason,
-            resolve: resolve14
+            resolve: resolve15
           });
         });
         const rule = { tool: "language_package", pattern: pending.suggestedPattern };
@@ -20801,21 +21163,21 @@ async function startWebUI(opts = {}) {
     });
   }
   async function touchProjectEntry(root, workDir) {
-    const resolved = path27.resolve(root);
+    const resolved = path28.resolve(root);
     const manifest = await loadManifest(globalConfigPath);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const existing = manifest.projects.find((p) => path27.resolve(p.root) === resolved);
+    const existing = manifest.projects.find((p) => path28.resolve(p.root) === resolved);
     if (existing) {
       existing.lastSeen = now;
-      if (workDir) existing.lastWorkingDir = path27.resolve(workDir);
+      if (workDir) existing.lastWorkingDir = path28.resolve(workDir);
     } else {
       manifest.projects.push({
-        name: path27.basename(resolved),
+        name: path28.basename(resolved),
         root: resolved,
         slug: generateProjectSlug(resolved),
         createdAt: now,
         lastSeen: now,
-        lastWorkingDir: workDir ? path27.resolve(workDir) : void 0
+        lastWorkingDir: workDir ? path28.resolve(workDir) : void 0
       });
     }
     await saveManifest(manifest, globalConfigPath);
@@ -20916,6 +21278,7 @@ async function startWebUI(opts = {}) {
   const cb = {
     sessionStartPayload,
     claimSession: (sessionId, target) => sessionIdentity.claim(sessionId, target),
+    onBeforeSessionTodosReplaced: todosCheckpoint.rebind,
     onSessionSwapped: async (sessionId, target) => {
       await sessionIdentity.activate(sessionId, target);
       const { hydrateSessionKanban: hydrateSessionKanban2 } = await import("@wrongstack/tools/session-kanban");
@@ -21066,6 +21429,7 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
       ...wssSecondary ? [wssSecondary] : []
     ],
     onShutdown: async () => {
+      await todosCheckpoint.detach();
       await stopHeapWatchdog();
       credentialWatcherClose?.();
       brainMonitor.stop();
@@ -21091,7 +21455,7 @@ projectRoot: ${ev.projectRoot ?? "?"}`,
       await memoryStore.dispose().catch(
         (err) => logger.warn(`sage connection disposal failed: ${toErrorMessage13(err)}`)
       );
-      await unregisterInstance(process.pid, path27.dirname(globalConfigPath));
+      await unregisterInstance(process.pid, path28.dirname(globalConfigPath));
     }
   });
 }