@wrongstack/webui-server 0.300.0 → 0.302.0

package/dist/server/entry.js

@@ -52,6 +52,7 @@ var BOOLEAN_PREF_KEYS = /* @__PURE__ */ new Set([
   "chime",
   "confirmExit",
   "nextPrediction",
+  "nextStepsTool",
   "titleAnimation",
   "enhanceEnabled",
   "featureMcp",
@@ -175,6 +176,7 @@ var ENUM_PREF_KEYS = {
   fsAccess: /* @__PURE__ */ new Set(["unrestricted", "project"]),
   // Chimera autoFix + auto-review cascade threshold
   chimeraAutoFix: /* @__PURE__ */ new Set(["off", "ask", "auto"]),
+  autoReviewModelSelection: /* @__PURE__ */ new Set(["round-robin", "random"]),
   autoReviewCascadeOn: /* @__PURE__ */ new Set(["off", "critical", "high"]),
   fleetChatVerbosity: /* @__PURE__ */ new Set(["off", "full"]),
   showAgentSwarmPanel: /* @__PURE__ */ new Set(["bottom", "sidebar", "off"])
@@ -4230,6 +4232,9 @@ async function handleConversationRoute(ws, msg, handlers) {
     case "user_message":
       await handlers.userMessage(ws, msg);
       return true;
+    case "topic.advice":
+      await handlers.topicAdvice(ws, msg);
+      return true;
     case "abort":
       await handlers.abort(ws, msg);
       return true;
@@ -4245,6 +4250,7 @@ async function handleConversationRoute(ws, msg, handlers) {
 }
 
 // src/server/conversation-operations.ts
+import { startFreshTopicContext, TopicShiftAdvisor } from "@wrongstack/core/execution";
 import {
   buildUserContentBlocks,
   IncomingImageError,
@@ -4261,6 +4267,7 @@ function requestedSessionId(msg) {
   return payload && typeof payload === "object" && typeof payload.sessionId === "string" ? payload.sessionId : void 0;
 }
 function createConversationOperations(ctx) {
+  const topicShiftAdvisor = new TopicShiftAdvisor();
   const sessionPayload2 = (payload) => {
     const provided = payload["sessionId"];
     const sessionId = typeof provided === "string" && provided.length > 0 ? provided : ctx.getSessionId();
@@ -4281,6 +4288,38 @@ function createConversationOperations(ctx) {
     return false;
   };
   return {
+    topicAdvice: async (ws, msg) => {
+      if (!ensureCurrentSession(ws, msg, "topic.advice")) return;
+      const payload = msg.payload ?? {};
+      if (typeof payload.requestId !== "string" || typeof payload.prompt !== "string") {
+        ctx.send(ws, {
+          type: "topic.advice_result",
+          payload: sessionPayload2({
+            requestId: typeof payload.requestId === "string" ? payload.requestId : "",
+            suggestNewContext: false,
+            confidence: 0,
+            reason: "Invalid topic advice request.",
+            source: "local"
+          })
+        });
+        return;
+      }
+      const agent = ctx.getAgent();
+      const configuredMax = agent.ctx.meta["effectiveMaxContext"];
+      const maxContext = typeof configuredMax === "number" ? configuredMax : agent.ctx.provider.capabilities.maxContext;
+      const advice = await topicShiftAdvisor.advise({
+        prompt: payload.prompt,
+        messages: agent.ctx.messages,
+        provider: agent.ctx.provider,
+        model: agent.ctx.model,
+        contextTokens: agent.ctx.lastRequestTokens,
+        maxContext
+      });
+      ctx.send(ws, {
+        type: "topic.advice_result",
+        payload: sessionPayload2({ requestId: payload.requestId, ...advice })
+      });
+    },
     userMessage: async (ws, msg) => {
       if (!ensureCurrentSession(ws, msg, "user_message")) return;
       const payload = msg.payload ?? {};
@@ -4298,6 +4337,7 @@ function createConversationOperations(ctx) {
       const originSessionId = ctx.getSessionId();
       try {
         const agent = ctx.getAgent();
+        if (payload.freshContext === true) await startFreshTopicContext(agent.ctx);
         const content = typeof payload.content === "string" ? payload.content : "";
         let input = content;
         const imageBlocks = parseIncomingImages(payload.images, payload.imageBase64);
@@ -5425,6 +5465,40 @@ import {
   getKanbanServerConnection,
   isKanbanServerAvailable
 } from "@wrongstack/kanban";
+import * as net from "node:net";
+
+// src/server/privileged-actions.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import {
+  isTrustDecisionAllowed
+} from "@wrongstack/core/security";
+async function authorizeWebUIAction(boundary, action, logger) {
+  const request = {
+    version: 1,
+    requestId: randomUUID2(),
+    actor: {
+      kind: "remote-client",
+      ...action.sessionId ? { sessionId: action.sessionId } : {}
+    },
+    surface: "webui",
+    capability: action.capability,
+    subject: action.subject,
+    risk: action.risk,
+    scope: {
+      ...action.cwd ? { cwd: action.cwd } : {},
+      ...action.sessionId ? { sessionId: action.sessionId } : {}
+    },
+    authContext: { method: "session" },
+    ...action.metadata ? { metadata: action.metadata } : {}
+  };
+  const decision = await boundary.evaluate(request);
+  logger?.debug?.(
+    `[trust-boundary] ${request.capability} ${decision.kind} request=${request.requestId}`
+  );
+  return { allowed: isTrustDecisionAllowed(decision), reason: decision.reason, request };
+}
+
+// src/server/connections-health-route.ts
 import { readGovernanceDaemonOperatorStatus } from "@wrongstack/runtime/governance-bootstrap";
 import { isSageProjectServerAvailable, SageProjectServerConnection } from "@wrongstack/sage";
 import {
@@ -5800,6 +5874,544 @@ async function governanceHealth(projectRoot) {
     }
   };
 }
+async function handleConnectionsServiceAction(ws, message, context) {
+  if (message.type !== "connections.service_action") return false;
+  const payload = message.payload;
+  const serviceId = payload?.serviceId;
+  const rawAction = payload?.action ?? "shutdown";
+  if (!serviceId) {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId: null,
+        action: rawAction,
+        success: false,
+        message: "Missing serviceId in payload"
+      }
+    });
+    return true;
+  }
+  if (rawAction !== "shutdown" && rawAction !== "restart") {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId,
+        action: rawAction,
+        success: false,
+        message: `Unsupported action "${rawAction}" \u2014 only "shutdown" and "restart" are supported`
+      }
+    });
+    return true;
+  }
+  const action = rawAction;
+  if (!context.trustBoundary) {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId,
+        action,
+        success: false,
+        message: "Service control is unavailable: no policy authority is configured."
+      }
+    });
+    return true;
+  }
+  const projectRootForAuth = context.getProjectRoot();
+  const authorization = await authorizeWebUIAction(
+    context.trustBoundary,
+    {
+      capability: `connections.service.${action}`,
+      subject: { kind: "process", id: `${serviceId}@${projectRootForAuth}` },
+      risk: "elevated",
+      cwd: projectRootForAuth,
+      metadata: { transport: "websocket", serviceId, action }
+    },
+    context.logger
+  );
+  if (!authorization.allowed) {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId,
+        action,
+        success: false,
+        message: authorization.reason ?? "Refused by policy."
+      }
+    });
+    return true;
+  }
+  if (serviceId === "webui") {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId: "webui",
+        action,
+        success: false,
+        message: action === "restart" ? "Cannot restart the WebUI transport itself" : "Cannot shut down the WebUI transport itself"
+      }
+    });
+    return true;
+  }
+  try {
+    const result = await executeServiceAction(
+      serviceId,
+      action,
+      context.getProjectRoot(),
+      context.getIndexDir()
+    );
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: result
+    });
+  } catch (error2) {
+    context.send(ws, {
+      type: "connections.service_action_result",
+      payload: {
+        serviceId,
+        action,
+        success: false,
+        message: error2 instanceof Error ? error2.message : String(error2)
+      }
+    });
+  }
+  return true;
+}
+async function executeServiceAction(serviceId, action, projectRoot, indexDir) {
+  switch (serviceId) {
+    case "kanban":
+      return killKanbanServer(projectRoot, action);
+    case "sage":
+      return killSageServer(projectRoot, action);
+    case "chronicle":
+      return killChronicleServer(projectRoot, action);
+    case "codebase-index":
+      return killCodebaseIndexServer(projectRoot, indexDir, action);
+    case "mailbox":
+      return killMailboxServer(projectRoot, action);
+    case "governance":
+      return {
+        serviceId: "governance",
+        action,
+        success: false,
+        message: "Governance health is read-only; daemon shutdown requires a separate admin control capability."
+      };
+    default:
+      return {
+        serviceId,
+        action,
+        success: false,
+        message: `Unknown service: ${serviceId}`
+      };
+  }
+}
+async function killKanbanServer(projectRoot, action) {
+  if (process.env["WRONGSTACK_KANBAN_SERVER"] === "0") {
+    return {
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: "Kanban IPC daemon is disabled via WRONGSTACK_KANBAN_SERVER=0"
+    };
+  }
+  let connection;
+  try {
+    connection = await getKanbanServerConnection(projectRoot);
+  } catch (error2) {
+    return {
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  }
+  if (!connection) {
+    return {
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: "Kanban IPC daemon is not running"
+    };
+  }
+  try {
+    const result = await connection.request("shutdown", {
+      reason: `WebUI request: ${action}`
+    });
+    if (!result.stopping) {
+      return {
+        serviceId: "kanban",
+        action,
+        success: false,
+        message: "Kanban IPC daemon shutdown failed (not confirmed)"
+      };
+    }
+    if (action === "restart") {
+      closeKanbanServerConnections();
+      const restartResult = await restartKanbanServer(projectRoot);
+      return restartResult;
+    }
+    return {
+      serviceId: "kanban",
+      action,
+      success: true,
+      message: "Kanban IPC daemon shutdown requested"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "kanban",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  }
+}
+async function restartKanbanServer(projectRoot) {
+  await waitForShutdown(() => isKanbanServerAvailable(projectRoot));
+  try {
+    const connection = await getKanbanServerConnection(projectRoot);
+    if (!connection) {
+      return {
+        serviceId: "kanban",
+        action: "restart",
+        success: false,
+        message: "Kanban IPC daemon failed to restart (no connection after re-init)"
+      };
+    }
+    await connection.request("ping", {}, { timeoutMs: 1e4 });
+    return {
+      serviceId: "kanban",
+      action: "restart",
+      success: true,
+      message: "Kanban IPC daemon restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "kanban",
+      action: "restart",
+      success: false,
+      message: `Kanban IPC daemon restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  }
+}
+async function killSageServer(projectRoot, action) {
+  if (!isSageProjectServerAvailable()) {
+    return {
+      serviceId: "sage",
+      action,
+      success: false,
+      message: "SAGE project server is unavailable in this runtime"
+    };
+  }
+  const connection = new SageProjectServerConnection(projectRoot);
+  try {
+    const result = await connection.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "sage",
+        action,
+        success: false,
+        message: `SAGE memory server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartSageServer(projectRoot);
+    }
+    return {
+      serviceId: "sage",
+      action,
+      success: true,
+      message: "SAGE memory server shutdown requested"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "sage",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  } finally {
+    connection.close();
+  }
+}
+async function restartSageServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new SageProjectServerConnection(projectRoot);
+    try {
+      return await probe.status() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new SageProjectServerConnection(projectRoot);
+  try {
+    await verifyConn.call("ping", {}, { timeoutMs: 1e4, meta: { clientId: `sage-restart-${process.pid}` } });
+    return {
+      serviceId: "sage",
+      action: "restart",
+      success: true,
+      message: "SAGE memory server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "sage",
+      action: "restart",
+      success: false,
+      message: `SAGE memory server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
+async function killChronicleServer(projectRoot, action) {
+  const options = resolveChronicleProjectServerOptions({ projectRoot });
+  const client = new ChronicleProjectServerClient(options);
+  try {
+    const result = await client.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "chronicle",
+        action,
+        success: false,
+        message: `Chronicle telemetry server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartChronicleServer(projectRoot);
+    }
+    return {
+      serviceId: "chronicle",
+      action,
+      success: true,
+      message: "Chronicle telemetry server shutdown requested"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "chronicle",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  } finally {
+    client.close();
+  }
+}
+async function restartChronicleServer(projectRoot) {
+  const options = resolveChronicleProjectServerOptions({ projectRoot });
+  const endpoint = new ChronicleProjectServerClient(options).endpoint;
+  await waitForShutdown(async () => isEndpointAlive(endpoint));
+  let access2;
+  try {
+    access2 = createChronicleProjectAccess2({ projectRoot });
+    await access2.call("ping", {}, { timeoutMs: 1e4 });
+    if (access2.mode !== "server") {
+      return {
+        serviceId: "chronicle",
+        action: "restart",
+        success: false,
+        message: `Chronicle telemetry server restarted but running in ${access2.mode} mode (expected server)`
+      };
+    }
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: true,
+      message: "Chronicle telemetry server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "chronicle",
+      action: "restart",
+      success: false,
+      message: `Chronicle telemetry server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    await access2?.close();
+  }
+}
+async function killCodebaseIndexServer(projectRoot, indexDir, action) {
+  try {
+    const result = await shutdownCodebaseIndexServer(
+      projectRoot,
+      indexDir,
+      `websocket-request:${action}`
+    );
+    if (!result.stopped) {
+      return {
+        serviceId: "codebase-index",
+        action,
+        success: false,
+        message: `Codebase index server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartCodebaseIndexServer(projectRoot, indexDir);
+    }
+    return {
+      serviceId: "codebase-index",
+      action,
+      success: true,
+      message: "Codebase index server shutdown requested"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "codebase-index",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  }
+}
+async function restartCodebaseIndexServer(projectRoot, indexDir) {
+  await waitForShutdown(async () => {
+    try {
+      await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+        timeoutMs: 1e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  try {
+    await ensureCodebaseIndexServer2({ projectRoot, indexDir });
+    const health = await checkCodebaseIndexServerHealth(projectRoot, indexDir, {
+      timeoutMs: 1e4
+    });
+    if (health.status === "unresponsive") {
+      return {
+        serviceId: "codebase-index",
+        action: "restart",
+        success: false,
+        message: "Codebase index server restarted but is unresponsive"
+      };
+    }
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: true,
+      message: "Codebase index server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "codebase-index",
+      action: "restart",
+      success: false,
+      message: `Codebase index server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  }
+}
+async function killMailboxServer(projectRoot, action) {
+  if (!isMailboxProjectServerAvailable()) {
+    return {
+      serviceId: "mailbox",
+      action,
+      success: false,
+      message: "Mailbox project server is unavailable in this runtime"
+    };
+  }
+  const connection = new MailboxProjectServerConnection(
+    resolveWstackPaths2({ projectRoot }).projectDir
+  );
+  try {
+    const result = await connection.shutdown(`WebUI request: ${action}`);
+    if (!result.stopped) {
+      return {
+        serviceId: "mailbox",
+        action,
+        success: false,
+        message: `Mailbox IPC server shutdown failed: ${result.reason ?? "unknown"}`
+      };
+    }
+    if (action === "restart") {
+      return await restartMailboxServer(projectRoot);
+    }
+    return {
+      serviceId: "mailbox",
+      action,
+      success: true,
+      message: "Mailbox IPC server shutdown requested"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "mailbox",
+      action,
+      success: false,
+      message: error2 instanceof Error ? error2.message : String(error2)
+    };
+  } finally {
+    connection.close();
+  }
+}
+async function restartMailboxServer(projectRoot) {
+  await waitForShutdown(async () => {
+    const probe = new MailboxProjectServerConnection(
+      resolveWstackPaths2({ projectRoot }).projectDir
+    );
+    try {
+      return await probe.probeStatus() !== null;
+    } finally {
+      probe.close();
+    }
+  });
+  const verifyConn = new MailboxProjectServerConnection(
+    resolveWstackPaths2({ projectRoot }).projectDir
+  );
+  try {
+    await verifyConn.call("ping", {}, { timeoutMs: 1e4 });
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: true,
+      message: "Mailbox IPC server restarted successfully"
+    };
+  } catch (error2) {
+    return {
+      serviceId: "mailbox",
+      action: "restart",
+      success: false,
+      message: `Mailbox IPC server restarted but verification failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    };
+  } finally {
+    verifyConn.close();
+  }
+}
+var RESTART_POLL_INTERVAL_MS = 250;
+var RESTART_DEADLINE_MS = 3e3;
+function isEndpointAlive(endpoint) {
+  return new Promise((resolve16) => {
+    const sock = net.createConnection(endpoint);
+    const timer = setTimeout(() => {
+      sock.destroy();
+      resolve16(false);
+    }, 500);
+    timer.unref?.();
+    sock.once("connect", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve16(true);
+    });
+    sock.once("error", () => {
+      clearTimeout(timer);
+      sock.destroy();
+      resolve16(false);
+    });
+  });
+}
+async function waitForShutdown(probe) {
+  if (!probe) {
+    await new Promise((resolve16) => setTimeout(resolve16, RESTART_POLL_INTERVAL_MS));
+    return;
+  }
+  const deadline = Date.now() + RESTART_DEADLINE_MS;
+  while (Date.now() < deadline) {
+    try {
+      const stillUp = await probe();
+      if (!stillUp) return;
+    } catch {
+      return;
+    }
+    await new Promise((resolve16) => setTimeout(resolve16, RESTART_POLL_INTERVAL_MS));
+  }
+}
 function failureService(id, label, required, mode, error2, latencyMs) {
   const message = error2 instanceof Error ? error2.message : String(error2);
   return {
@@ -5960,9 +6572,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((resolve15) => {
+    const git = (args) => new Promise((resolve16) => {
       ef("git", args, { cwd, timeout: 3e3 }, (err, stdout) => {
-        resolve15(err ? "" : stdout.trim());
+        resolve16(err ? "" : stdout.trim());
       });
     });
     const [branchRaw, diffRaw, statusRaw, upstreamRaw] = await Promise.all([
@@ -5988,12 +6600,12 @@ async function handleGitInfo(ws, projectRoot) {
 function makeGit(cwd) {
   return async (args) => {
     const { execFile: ef } = await import("node:child_process");
-    return new Promise((resolve15) => {
+    return new Promise((resolve16) => {
       ef(
         "git",
         args,
         { cwd, timeout: 5e3, maxBuffer: 1024 * 1024 * 16 },
-        (err, stdout) => resolve15(err ? "" : stdout)
+        (err, stdout) => resolve16(err ? "" : stdout)
       );
     });
   };
@@ -6158,7 +6770,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((resolve15) => {
+  return new Promise((resolve16) => {
     execFile(
       "git",
       [...args],
@@ -6169,7 +6781,7 @@ function gitStdout(cwd, args) {
         timeout: GIT_TIMEOUT_MS,
         maxBuffer: GIT_MAX_OUTPUT_BYTES
       },
-      (error2, stdout) => resolve15(error2 ? null : stdout)
+      (error2, stdout) => resolve16(error2 ? null : stdout)
     );
   });
 }
@@ -6460,14 +7072,14 @@ var GoalWebSocketHandler = class {
         const cwd = env?.cwd ?? this.projectRoot;
         try {
           const { execFile: execFile2 } = await import("node:child_process");
-          const result = await new Promise((resolve15) => {
+          const result = await new Promise((resolve16) => {
             const npxCommand = process.platform === "win32" ? "npx.cmd" : "npx";
             execFile2(npxCommand, ["tsc", "--noEmit"], { cwd, timeout: 6e4 }, (err, stdout, stderr) => {
               if (err && err.code === "ENOENT") {
-                resolve15("[verify] tsc not found \u2014 skipping");
+                resolve16("[verify] tsc not found \u2014 skipping");
                 return;
               }
-              resolve15(stdout + stderr);
+              resolve16(stdout + stderr);
             });
           });
           if (result.includes("[verify]") || result.trim().length === 0) {
@@ -6508,12 +7120,12 @@ Run npx tsc --noEmit to verify the fix. Output the fixed file paths.`;
         ...maybeVerify,
         onPhaseComplete: (phase) => {
           this.logger.info(`[Goal] Phase completed: ${phase.name}`);
-          void this.store.save(graph);
+          this.persistDetached(graph);
           this.broadcastState();
         },
         onPhaseFail: (phase, error2) => {
           this.logger.error(`[Goal] Phase failed: ${phase.name} \u2014 ${error2.message}`);
-          void this.store.save(graph);
+          this.persistDetached(graph);
           this.broadcastState();
         }
       },
@@ -6530,7 +7142,7 @@ Run npx tsc --noEmit to verify the fix. Output the fixed file paths.`;
     this.broadcastState();
     void this.orchestrator.start().then(() => {
       this.orchestrator?.stop();
-      void this.store.save(graph);
+      this.persistDetached(graph);
       this.stopBroadcast();
       const failed = graph.failedPhaseIds.length > 0;
       this.broadcast(
@@ -6728,9 +7340,27 @@ ${result_.finalText.slice(0, 2e3)}`
       this.logger.warn(`[Goal] Chimera review failed for "${task.title}": ${toErrorMessage2(err)}`);
     }
   }
+  /**
+   * Fire-and-forget persist.
+   *
+   * Every detached `store.save()` used to be a bare `void`, so a rejection
+   * became an unhandled rejection and — under Node 22's default
+   * `--unhandled-rejections=throw` — killed the process mid-run. On Windows an
+   * AV scanner or indexer holding the `.wrongstack/phases/<id>.json` rename
+   * target for a few hundred ms is enough (EPERM from `atomicWrite`), and in
+   * `--webui` mode that takes the CLI session down with it. `handleStop` at
+   * `:549` already had the `.catch`; these call sites did not.
+   */
+  persistDetached(graph) {
+    void this.store.save(graph).catch((err) => {
+      this.logger.warn(
+        `[Goal] Failed to persist phase graph: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  }
   /** Persist + broadcast after an interactive board mutation. */
   afterBoardMutation() {
-    if (this.graph) void this.store.save(this.graph);
+    if (this.graph) this.persistDetached(this.graph);
     this.broadcastState();
   }
   async handleTaskStatusChange(taskId, status) {
@@ -7187,7 +7817,7 @@ function pushEvent(event) {
   }
 }
 function parseBody(req) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     let body = "";
     let bodyBytes = 0;
     let tooLarge = false;
@@ -7207,7 +7837,7 @@ function parseBody(req) {
         return;
       }
       try {
-        resolve15(JSON.parse(body));
+        resolve16(JSON.parse(body));
       } catch {
         reject(new Error("Invalid JSON"));
       }
@@ -7294,7 +7924,7 @@ 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) => {
+  return new Promise((resolve16, reject) => {
     const chunks = [];
     let total = 0;
     req.on("data", (chunk) => {
@@ -7306,7 +7936,7 @@ function readJsonBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve15(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve16(Buffer.concat(chunks).toString("utf8")));
     req.on("error", (err) => reject(err));
   });
 }
@@ -7714,12 +8344,21 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
     const paths = resolveWstackPaths7({ projectRoot: entry.projectRoot, globalRoot });
     const store = new DefaultSessionStore3({ dir: paths.projectSessions });
     const reader = new DefaultSessionReader2({ store });
-    const rawEntries = [];
+    const RING = Math.max(limit * 4, 2e3);
+    const ring = [];
+    let totalRaw = 0;
+    let dropped = false;
     for await (const ev of reader.replay(sessionId)) {
       const mapped = mapWatchEntry(ev);
-      if (mapped) rawEntries.push(mapped);
+      if (!mapped) continue;
+      totalRaw += 1;
+      ring.push(mapped);
+      if (ring.length > RING) {
+        ring.shift();
+        dropped = true;
+      }
     }
-    const all = correlateToolEvents(rawEntries);
+    const all = correlateToolEvents(ring);
     const tail2 = all.slice(-limit);
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(
@@ -7728,7 +8367,12 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
         status: entry.status,
         clientType: entry.clientType,
         projectName: entry.projectName,
-        total: all.length,
+        // Exact when the whole session fit in the ring (the previous
+        // behaviour). Past that, correlation never ran over the dropped
+        // prefix, so report the raw event count — an upper bound — and say so
+        // rather than silently understating the session's size.
+        total: dropped ? totalRaw : all.length,
+        ...dropped ? { truncated: true } : {},
         entries: tail2
       })
     );
@@ -7738,7 +8382,7 @@ async function handleApiSessionEvents(res, globalRoot, sessionId, limit) {
   }
 }
 function readJsonBody2(req) {
-  return new Promise((resolve15, reject) => {
+  return new Promise((resolve16, reject) => {
     const contentType = (req.headers["content-type"] ?? "").split(";")[0]?.trim().toLowerCase();
     if (contentType !== "application/json") {
       reject(new Error(`Unsupported Content-Type: ${contentType || "(absent)"}`));
@@ -7754,7 +8398,7 @@ function readJsonBody2(req) {
     });
     req.on("end", () => {
       try {
-        resolve15(data ? JSON.parse(data) : {});
+        resolve16(data ? JSON.parse(data) : {});
       } catch (err) {
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -8030,14 +8674,14 @@ async function readJsonBody3(res, req) {
     });
     return null;
   }
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     let data = "";
     let failed = false;
     const fail2 = (message) => {
       if (failed) return;
       failed = true;
       sendJson2(res, 400, { error: { code: "INVALID_BODY", message } });
-      resolve15(null);
+      resolve16(null);
     };
     req.on("data", (chunk) => {
       if (failed) return;
@@ -8050,7 +8694,7 @@ async function readJsonBody3(res, req) {
     req.on("end", () => {
       if (failed) return;
       try {
-        resolve15(data.trim().length === 0 ? {} : JSON.parse(data));
+        resolve16(data.trim().length === 0 ? {} : JSON.parse(data));
       } catch {
         fail2("Request body is not valid JSON");
       }
@@ -8418,7 +9062,7 @@ async function touchProjectInManifest(options, globalConfigPath) {
 }
 
 // src/server/techstack-handlers.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var DEEP_DIVE_TIMEOUT_MS = 6e4;
 function sendJson3(res, status, data) {
   res.writeHead(status, { "Content-Type": "application/json" });
@@ -8459,7 +9103,7 @@ function requireJobDeps(res, deps2) {
 }
 function startJob(res, deps2, kind) {
   if (!requireJobDeps(res, deps2)) return;
-  const jobId = randomUUID2();
+  const jobId = randomUUID3();
   const controller = new AbortController();
   deps2.runningJobs?.set(jobId, controller);
   deps2.emit?.({ type: "techstack.job.started", payload: { jobId, kind } });
@@ -8889,7 +9533,7 @@ function strictDecodeParam(segment, res) {
 function createHttpServer(opts) {
   const port = opts.port ?? Number.parseInt(process.env["PORT"] ?? "3456", 10);
   const distDir = path13.resolve(opts.distDir);
-  const requireAccessToken = true;
+  const requireAccessToken = Boolean(opts.requireToken) || !isLoopbackBind(opts.host);
   const secureCookies = opts.secureCookies ?? (opts.publicWsUrl?.trim().toLowerCase().startsWith("wss:") ?? false);
   const trustedHostnames = (() => {
     const names = [...opts.allowedHostnames ?? []];
@@ -8925,7 +9569,7 @@ function createHttpServer(opts) {
         res.end(JSON.stringify({ error: "forbidden: untrusted request origin" }));
         return;
       }
-      const providedAccessToken = requestToken(req, url);
+      const providedAccessToken = requestToken(req, url, { allowQuery: true });
       const accessTokenOk = Boolean(opts.apiToken) && tokenMatches(providedAccessToken, opts.apiToken ?? "");
       const shouldSetAuthCookie = Boolean(opts.apiToken) && tokenMatches(url.searchParams.get("token") ?? void 0, opts.apiToken ?? "");
       if (url.pathname === "/ws-auth" && req.method === "GET" && (opts.enableWsCookie ?? true)) {
@@ -9435,9 +10079,9 @@ function createHttpServer(opts) {
 }
 
 // src/server/instance-registry.ts
+import * as fs11 from "node:fs/promises";
 import * as os from "node:os";
 import * as path14 from "node:path";
-import * as fs11 from "node:fs/promises";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core/utils";
 function defaultBaseDir() {
   return path14.join(os.homedir(), ".wrongstack");
@@ -9779,6 +10423,27 @@ import {
   getServerKanbanStore
 } from "@wrongstack/kanban";
 import { recordKanbanVerificationEvidence } from "@wrongstack/tools";
+
+// src/server/kanban-broadcast.ts
+function kanbanBoardMessage(board) {
+  return { type: "kanban.get", payload: { success: true, data: { board } } };
+}
+function kanbanListMessage(boards) {
+  return { type: "kanban.list", payload: { success: true, data: boards } };
+}
+function kanbanDeletedMessage(boardId) {
+  return { type: "kanban.delete", payload: { success: true, data: { removed: true, boardId } } };
+}
+async function publishKanbanBoard(broadcast2, board, listBoards4) {
+  broadcast2(kanbanBoardMessage(board));
+  if (!listBoards4) return;
+  try {
+    broadcast2(kanbanListMessage(await listBoards4()));
+  } catch {
+  }
+}
+
+// src/server/kanban-dispatch.ts
 function reply(ws, type, success, value) {
   send(ws, {
     type,
@@ -9895,10 +10560,7 @@ async function handleKanbanTaskDispatch(ws, payload, ctx) {
           payload: { success: true, data: { boardId: board.id, task: completedTask } }
         });
         if (completedBoard) {
-          ctx.broadcast?.({
-            type: "kanban.get",
-            payload: { success: true, data: { board: completedBoard } }
-          });
+          ctx.broadcast?.(kanbanBoardMessage(completedBoard));
         }
         ctx.broadcast?.({
           type: "kanban.list",
@@ -9922,7 +10584,7 @@ async function handleKanbanTaskDispatch(ws, payload, ctx) {
       payload: { success: true, data: { boardId: board.id, task: runningTask } }
     });
     if (started?.board) {
-      ctx.broadcast?.({ type: "kanban.get", payload: { success: true, data: { board: started.board } } });
+      ctx.broadcast?.(kanbanBoardMessage(started.board));
     }
     reply(ws, "kanban.task.dispatch", true, { boardId: board.id, task: runningTask, summary });
   } catch (error2) {
@@ -10165,14 +10827,11 @@ async function handleDecompositionResolution(ws, type, payload, ctx) {
       type: "kanban.decomposition.applied",
       payload: { success: true, data: { board: resolved.board } }
     });
-    ctx.broadcast?.({
-      type: "kanban.get",
-      payload: { success: true, data: { board: resolved.board } }
-    });
-    ctx.broadcast?.({
-      type: "kanban.list",
-      payload: { success: true, data: await listBoards(ctx.projectRoot) }
-    });
+    await publishKanbanBoard(
+      (message) => ctx.broadcast?.(message),
+      resolved.board,
+      () => listBoards(ctx.projectRoot)
+    );
   } else {
     ctx.broadcast?.({
       type: "kanban.decomposition.resolved",
@@ -10205,10 +10864,7 @@ async function handleTaskVerification(ws, type, payload, ctx) {
       payload: { success: true, data: { boardId, task: freshTask } }
     });
     if (persisted) {
-      ctx.broadcast?.({
-        type: "kanban.get",
-        payload: { success: true, data: { board: persisted } }
-      });
+      ctx.broadcast?.(kanbanBoardMessage(persisted));
     }
   } catch (err) {
     ctx.broadcast?.({
@@ -11084,10 +11740,7 @@ function subscribeKanbanDaemonEvents(projectRoot, broadcastMessage) {
   let connectionCount = 0;
   const broadcastDeleted = (boardId) => {
     knownRevisions.delete(boardId);
-    broadcastMessage({
-      type: "kanban.delete",
-      payload: { success: true, data: { removed: true, boardId } }
-    });
+    broadcastMessage(kanbanDeletedMessage(boardId));
   };
   const broadcastBoard = async (boardId) => {
     const board = await store.getBoard(boardId);
@@ -11096,10 +11749,7 @@ function subscribeKanbanDaemonEvents(projectRoot, broadcastMessage) {
       return;
     }
     knownRevisions.set(boardId, board.updatedAt);
-    broadcastMessage({
-      type: "kanban.get",
-      payload: { success: true, data: { board } }
-    });
+    broadcastMessage(kanbanBoardMessage(board));
   };
   const reconcileAfterConnect = async () => {
     const summaries = await store.listBoards();
@@ -11118,20 +11768,36 @@ function subscribeKanbanDaemonEvents(projectRoot, broadcastMessage) {
       }
     }
   };
-  return bridgeKanbanSupervisor(
+  const COALESCE_MS = 300;
+  const pendingBroadcasts = /* @__PURE__ */ new Map();
+  const scheduleBroadcast = (boardId) => {
+    if (pendingBroadcasts.has(boardId)) return;
+    const timer = setTimeout(() => {
+      pendingBroadcasts.delete(boardId);
+      void broadcastBoard(boardId).catch(() => {
+      });
+    }, COALESCE_MS);
+    timer.unref?.();
+    pendingBroadcasts.set(boardId, timer);
+  };
+  const unsubscribe = bridgeKanbanSupervisor(
     projectRoot,
     async (event) => {
+      const family = event.event?.split(".")[0];
+      if (family !== "board" && family !== "task" && family !== "column") return;
       const evData = event.data;
       const boardId = evData?.boardId;
       if (!boardId) return;
-      try {
-        if (event.event === "board.deleted") {
-          broadcastDeleted(boardId);
-          return;
+      if (event.event === "board.deleted") {
+        const timer = pendingBroadcasts.get(boardId);
+        if (timer) {
+          clearTimeout(timer);
+          pendingBroadcasts.delete(boardId);
         }
-        await broadcastBoard(boardId);
-      } catch {
+        broadcastDeleted(boardId);
+        return;
       }
+      scheduleBroadcast(boardId);
     },
     {
       autoReconnect: true,
@@ -11139,6 +11805,11 @@ function subscribeKanbanDaemonEvents(projectRoot, broadcastMessage) {
       onConnected: reconcileAfterConnect
     }
   );
+  return () => {
+    for (const timer of pendingBroadcasts.values()) clearTimeout(timer);
+    pendingBroadcasts.clear();
+    unsubscribe();
+  };
 }
 
 // src/server/lifecycle.ts
@@ -11155,7 +11826,13 @@ function createShutdown(res) {
     } catch (e) {
       log(`[WebUI] Error closing session: ${e instanceof Error ? e.message : String(e)}`);
     }
-    for (const ws of res.clients()) ws.close();
+    for (const ws of res.clients()) {
+      try {
+        ws.close();
+        ws.terminate?.();
+      } catch {
+      }
+    }
     for (const server of res.servers) server?.close();
     if (res.onShutdown) {
       try {
@@ -11592,39 +12269,6 @@ import {
   restartMcp,
   updateMcp
 } from "@wrongstack/mcp";
-
-// src/server/privileged-actions.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import {
-  isTrustDecisionAllowed
-} from "@wrongstack/core/security";
-async function authorizeWebUIAction(boundary, action, logger) {
-  const request = {
-    version: 1,
-    requestId: randomUUID3(),
-    actor: {
-      kind: "remote-client",
-      ...action.sessionId ? { sessionId: action.sessionId } : {}
-    },
-    surface: "webui",
-    capability: action.capability,
-    subject: action.subject,
-    risk: action.risk,
-    scope: {
-      ...action.cwd ? { cwd: action.cwd } : {},
-      ...action.sessionId ? { sessionId: action.sessionId } : {}
-    },
-    authContext: { method: "session" },
-    ...action.metadata ? { metadata: action.metadata } : {}
-  };
-  const decision = await boundary.evaluate(request);
-  logger?.debug?.(
-    `[trust-boundary] ${request.capability} ${decision.kind} request=${request.requestId}`
-  );
-  return { allowed: isTrustDecisionAllowed(decision), reason: decision.reason, request };
-}
-
-// src/server/mcp-handlers.ts
 async function authorizeMcpMutation(ws, operation, serverName, trustBoundary) {
   if (!trustBoundary) return true;
   const authorization = await authorizeWebUIAction(trustBoundary, {
@@ -12856,19 +13500,19 @@ function createModelOperations(context) {
 }
 
 // src/server/port-utils.ts
-import * as net from "node:net";
+import * as net2 from "node:net";
 import { ToolValidationError as ToolValidationError4 } from "@wrongstack/core/types";
 function isPortFree(host, port) {
-  return new Promise((resolve15) => {
-    const srv = net.createServer();
-    srv.once("error", () => resolve15(false));
+  return new Promise((resolve16) => {
+    const srv = net2.createServer();
+    srv.once("error", () => resolve16(false));
     srv.once("listening", () => {
-      srv.close(() => resolve15(true));
+      srv.close(() => resolve16(true));
     });
     try {
       srv.listen(port, host);
     } catch {
-      resolve15(false);
+      resolve16(false);
     }
   });
 }
@@ -13122,6 +13766,7 @@ function seedContextMeta(config, context) {
   meta["enhanceDelayMs"] = autonomyCfg["enhanceDelayMs"] ?? 6e4;
   meta["enhanceLanguage"] = autonomyCfg["enhanceLanguage"] ?? "original";
   meta["nextPrediction"] = config.nextPrediction ?? false;
+  meta["nextStepsTool"] = config.tools?.nextsteps?.enabled === true;
   meta["fallbackModels"] = config.fallbackModels ?? [];
   meta["fallbackBridge"] = config.fallbackBridge ?? "";
   meta["fallbackProfiles"] = config.fallbackProfiles ?? {};
@@ -13210,6 +13855,7 @@ function seedContextMeta(config, context) {
   meta["autoReviewProvider"] = autoReviewExt?.["provider"] ?? "";
   meta["autoReviewModel"] = autoReviewExt?.["model"] ?? "";
   meta["autoReviewFallbackProfile"] = autoReviewExt?.["fallbackProfile"] ?? "";
+  meta["autoReviewModelSelection"] = autoReviewExt?.["modelSelection"] === "random" ? "random" : "round-robin";
   meta["autoReviewFallbackModels"] = Array.isArray(autoReviewExt?.["fallbackModels"]) ? autoReviewExt?.["fallbackModels"] : [];
   meta["autoReviewDebounceMs"] = typeof autoReviewExt?.["debounceMs"] === "number" && autoReviewExt["debounceMs"] >= 0 ? autoReviewExt["debounceMs"] : 15e3;
   meta["autoReviewMaxFilesPerBatch"] = typeof autoReviewExt?.["maxFilesPerBatch"] === "number" && autoReviewExt["maxFilesPerBatch"] >= 1 ? autoReviewExt["maxFilesPerBatch"] : 15;
@@ -13247,6 +13893,7 @@ var PREF_KEYS = [
   "chime",
   "confirmExit",
   "nextPrediction",
+  "nextStepsTool",
   "enhanceEnabled",
   "enhanceDelayMs",
   "enhanceLanguage",
@@ -13310,6 +13957,7 @@ var PREF_KEYS = [
   "autoReviewProvider",
   "autoReviewModel",
   "autoReviewFallbackProfile",
+  "autoReviewModelSelection",
   "autoReviewFallbackModels",
   "autoReviewDebounceMs",
   "autoReviewMaxFilesPerBatch",
@@ -13523,6 +14171,11 @@ async function persistPrefsToConfig(deps2, holder, payload) {
         toolsCfg.maxIterations = payload["maxIterations"];
         decrypted.tools = toolsCfg;
       }
+      if (typeof payload["nextStepsTool"] === "boolean") {
+        const toolsCfg = decrypted.tools ?? {};
+        toolsCfg.nextsteps = { enabled: payload["nextStepsTool"] };
+        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 ?? {};
@@ -13630,7 +14283,7 @@ async function persistPrefsToConfig(deps2, holder, payload) {
         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";
+      const autoReviewTouched = typeof payload["autoReviewEnabled"] === "boolean" || typeof payload["autoReviewProvider"] === "string" || typeof payload["autoReviewModel"] === "string" || typeof payload["autoReviewFallbackProfile"] === "string" || typeof payload["autoReviewModelSelection"] === "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"] ?? {};
@@ -13647,6 +14300,9 @@ async function persistPrefsToConfig(deps2, holder, payload) {
             ar["fallbackProfile"] = payload["autoReviewFallbackProfile"];
           }
         }
+        if (payload["autoReviewModelSelection"] === "round-robin" || payload["autoReviewModelSelection"] === "random") {
+          ar["modelSelection"] = payload["autoReviewModelSelection"];
+        }
         if (typeof payload["autoReviewDebounceMs"] === "number" && payload["autoReviewDebounceMs"] >= 0) {
           ar["debounceMs"] = payload["autoReviewDebounceMs"];
         }
@@ -14007,6 +14663,7 @@ function createProjectHandlers(ctx) {
         ctx.context.session = next;
         ctx.context.state.replaceMessages([]);
         ctx.context.state.replaceTodos([]);
+        ctx.context.clearMemoryEvidence?.();
         ctx.context.readFiles.clear();
         ctx.context.fileMtimes.clear();
         ctx.tokenCounter.reset();
@@ -14051,7 +14708,7 @@ function createProjectHandlers(ctx) {
 }
 
 // src/server/provider-handlers.ts
-import { resolveProviderModelList } from "@wrongstack/core/models";
+import { hasProviderCredential, resolveProviderModelList } from "@wrongstack/core/models";
 import { DefaultSecretScrubber as DefaultSecretScrubber2 } from "@wrongstack/core/security";
 import { toErrorMessage as toErrorMessage6 } from "@wrongstack/core/utils";
 import {
@@ -14358,7 +15015,7 @@ function createProviderOperations(deps2) {
     }
     try {
       const providers = await deps2.modelsRegistry.listProviders();
-      const savedIds = new Set(Object.keys(await loadConfigProviders()));
+      const savedProviders = await loadConfigProviders();
       sendMessage(ws, {
         type: "provider.catalog",
         payload: {
@@ -14369,7 +15026,7 @@ function createProviderOperations(deps2) {
             apiBase: provider.apiBase,
             envVars: provider.envVars,
             modelCount: provider.models.length,
-            hasApiKey: savedIds.has(provider.id) || provider.envVars.some((name2) => !!process.env[name2])
+            hasApiKey: hasProviderCredential(provider, { providers: savedProviders })
           }))
         }
       });
@@ -14853,6 +15510,7 @@ var CLIENT_CONVERSATION_MESSAGE_TYPES = [
   "ping",
   "user_message",
   "tool.confirm_result",
+  "topic.advice",
   "completion.request",
   "model.switch",
   "model.refine",
@@ -15155,6 +15813,7 @@ var SERVER_CONVERSATION_MESSAGE_TYPES = [
   "tool.loop_detected",
   "tool.progress",
   "tool.started",
+  "topic.advice_result",
   "tools.list",
   "trust.persisted"
 ];
@@ -15486,6 +16145,8 @@ var SURFACE_PROTOCOL_CAPABILITIES = [
   "chronicle.metrics",
   "chronicle.status",
   "connections.health",
+  /** Bounded topic-shift advice plus same-session provider-context boundaries. */
+  "context.topic-boundary",
   /** Interview resume/discard + lastAgentText/lastRunId continuity. */
   "sdd.interview.continuity",
   /** Launch multi-agent runs from a graph id or resolved spec id. */
@@ -15877,6 +16538,7 @@ function createSessionHandlers(ctx) {
     await ctx.onBeforeSessionTodosReplaced?.(next.id, sessionsDirectory());
     ctx.context.state.replaceTodos(todos);
     resetContextAccounting();
+    ctx.context.clearMemoryEvidence?.();
     ctx.context.readFiles.clear();
     ctx.context.fileMtimes.clear();
     ctx.context.state.setMeta?.(
@@ -15924,6 +16586,7 @@ function createSessionHandlers(ctx) {
         ctx.context.state.replaceMessages([]);
         ctx.context.state.replaceTodos([]);
         resetContextAccounting();
+        ctx.context.clearMemoryEvidence?.();
         ctx.context.readFiles.clear();
         ctx.context.fileMtimes.clear();
         ctx.tokenCounter.reset?.();
@@ -15938,6 +16601,7 @@ function createSessionHandlers(ctx) {
       ctx.context.state.replaceMessages([]);
       ctx.context.state.replaceTodos([]);
       resetContextAccounting();
+      ctx.context.clearMemoryEvidence?.();
       ctx.context.readFiles.clear();
       ctx.context.fileMtimes.clear();
       ctx.tokenCounter.reset?.();
@@ -18408,7 +19072,7 @@ function registerSetupEventsClientStatusWriter(deps2) {
   const on = (event, listener) => events.on(event, listener);
   return on("client.status", async (e) => {
     broadcast2(clients, { type: "client.status_update", payload: e });
-    if (wpaths?.projectStatus) {
+    if (wpaths?.projectStatus && e.projectHash !== "unknown") {
       try {
         const statusFile = wpaths.projectStatus(e.projectHash);
         const dir = path19.dirname(statusFile);
@@ -18583,7 +19247,10 @@ function registerSetupEventsProviderHandlers({
         sessionId: e.sessionId,
         providerId: e.providerId,
         modelId: e.modelId,
-        maxContext: e.maxContext
+        maxContext: e.maxContext,
+        ...e.previousMaxContext !== void 0 ? { previousMaxContext: e.previousMaxContext } : {},
+        ...e.source !== void 0 ? { source: e.source } : {},
+        ...e.decreased !== void 0 ? { decreased: e.decreased } : {}
       })
     });
   });
@@ -19693,7 +20360,15 @@ var SpecsWebSocketHandler = class {
     this.clients.add(client);
     ws.on("close", () => this.clients.delete(client));
     ws.on("error", () => this.clients.delete(client));
-    void this.sendList(client);
+    void this.sendList(client).catch((err) => {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "specs.initial_send_failed",
+          message: err instanceof Error ? err.message : String(err)
+        })
+      );
+    });
   }
   dispose() {
     this.clients.clear();
@@ -19907,15 +20582,17 @@ import {
 
 // src/server/discover-mailbox-bridge.ts
 import { spawn as spawn2 } from "node:child_process";
-import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname as dirname7, join as join10 } from "node:path";
-import { resolveProjectDir as resolveProjectDir2 } from "@wrongstack/core/coordination";
+import {
+  readLiveLock,
+  resolveProjectDir as resolveProjectDir2
+} from "@wrongstack/core/coordination";
 import { wstackGlobalRoot } from "@wrongstack/core/utils";
-import { readLiveLock } from "@wrongstack/core/coordination";
 var MAILBOX_BRIDGE_BOOT_TIMEOUT_MS = 5e3;
 async function discoverMailboxBridgeForWebui(params) {
-  const mode = params.config?.features?.mailboxBridge ?? "auto";
+  const mode = params.config?.features?.mailboxBridge ?? "off";
   if (mode === "off") return;
   const projectDir = resolveProjectDir2(params.projectRoot, wstackGlobalRoot());
   let result = await readLiveLock(projectDir);
@@ -20047,7 +20724,7 @@ function findWorkspaceCliEntry(projectRoot) {
   return null;
 }
 function sleep(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // src/server/terminal-ws-handler.ts
@@ -20177,6 +20854,13 @@ var TerminalWebSocketHandler = class {
       this.send(ws, { type: "terminal.exit", payload: { id: payload.id, exitCode: -1 } });
       return;
     }
+    if (this.sessions.get(ws) !== map) {
+      this.logger.info?.(
+        `terminal.create raced a disconnect (id=${payload.id}) \u2014 killing the orphan`
+      );
+      this.killPty(pty, "terminal create after disconnect");
+      return;
+    }
     map.set(payload.id, pty);
     this.logger.info?.(`terminal.create spawned (id=${payload.id}, pid=${pty.pid ?? "?"}) in ${cwd}`);
     pty.onData((data) => {
@@ -20283,7 +20967,7 @@ function clampDim(value, fallback) {
 }
 
 // src/server/worktree-ws-handler.ts
-import { join as join11, resolve as resolve12, sep as sep5 } from "node:path";
+import { join as join11, resolve as resolve13, sep as sep5 } from "node:path";
 import { toErrorMessage as toErrorMessage8 } from "@wrongstack/core/utils";
 import { WorktreeManager as WorktreeManager3 } from "@wrongstack/core/worktree";
 import { cleanupStaleSddWorktrees as cleanupStaleSddWorktrees2 } from "@wrongstack/sdd";
@@ -20368,11 +21052,11 @@ var WorktreeWebSocketHandler = class {
   // ── orphan management ─────────────────────────────────────────────────────
   /** Absolute managed-worktrees root for this project. */
   worktreesRoot() {
-    return resolve12(join11(this.management.projectRoot, ".wrongstack", "worktrees"));
+    return resolve13(join11(this.management.projectRoot, ".wrongstack", "worktrees"));
   }
   /** True iff `dir` resolves strictly inside the managed worktrees root. */
   underRoot(dir) {
-    const abs = resolve12(dir);
+    const abs = resolve13(dir);
     const root = this.worktreesRoot();
     return abs !== root && abs.startsWith(root + sep5);
   }
@@ -20596,7 +21280,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(resolve12(dir), base);
+    const summary = await wt.diffSummary(resolve13(dir), base);
     this.broadcast({ type: "worktree.diff_result", payload: { dir, summary } });
   }
   // ── internals ───────────────────────────────────────────────────────────
@@ -21602,6 +22286,15 @@ function createMessageDispatcher(opts) {
       msg
     ))
       return;
+    if (await handleConnectionsServiceAction(ws, msg, {
+      trustBoundary: deps2.trustBoundary,
+      logger: deps2.logger,
+      getProjectRoot: state.getProjectRoot,
+      getIndexDir: () => typeof deps2.context.meta["codebaseIndexDir"] === "string" ? deps2.context.meta["codebaseIndexDir"] : void 0,
+      send,
+      backend: "standalone"
+    }))
+      return;
     if (await handleCodebaseIndexServerControl(ws, msg, {
       trustBoundary: deps2.trustBoundary,
       logger: deps2.logger,
@@ -22108,6 +22801,7 @@ async function createPreContextServices(input) {
       registry: toolRegistry,
       tier: normalizeTokenSavingTier(config.features.tokenSavingMode),
       memory: { enabled: config.features.memory, store: memoryStore },
+      nextSteps: { enabled: config.tools?.nextsteps?.enabled === true },
       coordinationTools: [
         makeMailboxTool({ projectDir: wpaths.projectDir, events }),
         makeMailSendTool({ projectDir: wpaths.projectDir, events }),
@@ -23216,7 +23910,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((resolve15) => {
+        const decision = await new Promise((resolve16) => {
           events.emit("tool.confirm_needed", {
             sessionId: context.session.id,
             tool: confirmTool,
@@ -23226,7 +23920,7 @@ async function startWebUI(opts = {}) {
             decisionSource: pending.decisionSource,
             riskTier: pending.riskTier,
             boundaryReason: pending.boundaryReason,
-            resolve: resolve15
+            resolve: resolve16
           });
         });
         const rule = { tool: "language_package", pattern: pending.suggestedPattern };
@@ -23295,7 +23989,8 @@ async function startWebUI(opts = {}) {
     watcherMetricsRef
   );
   httpServer.listen(httpPort, wsHost, () => {
-    console.log(`[WebUI] HTTP server running on http://${wsHost}:${httpPort}`);
+    const tokenQuery = accessToken ? `/?token=${encodeURIComponent(accessToken)}` : "";
+    console.log(`[WebUI] HTTP server running on http://${wsHost}:${httpPort}${tokenQuery}`);
     const extraUrls = formatExternalAccessUrls({
       bindHost: wsHost,
       port: httpPort,
@@ -23317,8 +24012,11 @@ async function startWebUI(opts = {}) {
       (req, socket, head2) => httpServer.emit("upgrade", req, socket, head2)
     );
     companionServer.on("error", (err) => {
-      if (err.code !== "EAFNOSUPPORT" && err.code !== "EADDRNOTAVAIL" && err.code !== "EADDRINUSE") {
-        throw err;
+      const expected = err.code === "EAFNOSUPPORT" || err.code === "EADDRNOTAVAIL" || err.code === "EADDRINUSE";
+      if (!expected) {
+        console.warn(
+          `[WebUI] companion listener on ${companionLabel} failed (${err.code ?? "unknown"}): ${err.message}. The primary address is unaffected.`
+        );
       }
     });
     companionServer.listen(httpPort, companion, () => {
@@ -23560,24 +24258,23 @@ async function startWebUI(opts = {}) {
     clients,
     pendingConfirms,
     onSecurityRejection: (ev) => {
-      try {
-        void mailbox.send({
-          from: context.agentId,
-          to: "*",
-          type: "note",
-          audience: "leaders",
-          subject: `Security rejection: ${ev.issueCode}`,
-          body: `Decoder tripwire ${ev.issueCode}: ${ev.issueMessage}
+      void mailbox.send({
+        from: context.agentId,
+        to: "*",
+        type: "note",
+        audience: "leaders",
+        subject: `Security rejection: ${ev.issueCode}`,
+        body: `Decoder tripwire ${ev.issueCode}: ${ev.issueMessage}
 
 connectionId: ${ev.connectionId ?? "?"}
 sessionId: ${ev.sessionId ?? "?"}
 agentId: ${ev.agentId ?? "?"}
 projectRoot: ${ev.projectRoot ?? "?"}`,
-          priority: "high",
-          senderSessionId: session.id
-        });
-      } catch {
-      }
+        priority: "high",
+        senderSessionId: session.id
+      }).catch((err) => {
+        console.warn(`[WebUI] security-rejection mailbox note failed: ${String(err)}`);
+      });
     },
     goalHandler,
     specsHandler,