@wrongstack/cli 0.313.1 → 0.316.1

package/dist/{webui-server-I53IYBW4.js → webui-server-LZOEH7O6.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-VCYZ3WZV.js";
 import {
   startCliHqConnection
-} from "./chunk-FKWHSFX4.js";
+} from "./chunk-XYKYXFEE.js";
 import {
   WEBUI_SESSION_CHILD_CAPABILITIES
-} from "./chunk-3JPTNADJ.js";
+} from "./chunk-GPPRNAKW.js";
 import {
   loadConfigProviders,
   mutateConfigProviders
@@ -19,19 +19,31 @@ import "./chunk-7OCVIDC7.js";
 // src/webui-server.ts
 import * as path7 from "node:path";
 import { createCompatibilityTrustBoundary, DefaultSecretScrubber } from "@wrongstack/core/security";
-import { startSharedHeapWatchdog, wstackGlobalRoot } from "@wrongstack/core/utils";
+import {
+  addFatalSalvageHook,
+  startSharedHeapWatchdog,
+  wstackGlobalRoot
+} from "@wrongstack/core/utils";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils/error";
 import {
   buildWebUIAccessUrl,
+  clientWantsSession,
+  collectDisplayedSessionIds,
   createCustomModeStore,
   createEmbeddedMessageRouter,
   createEmbeddedProviderOperations,
+  createSessionAgentRegistry,
   envFlag,
   findFreePort,
   findInstalledPackageJson,
   isStrictPort,
   resolveAuthToken,
-  sendSerialized
+  resolvePendingConfirmsForSession,
+  scheduleOwnerlessEmptySessionCleanup,
+  sendSerialized,
+  startTerminalDashboard,
+  startWebUILiveStatusLogger,
+  toSessionHistoryEntries
 } from "@wrongstack/webui-server";
 import { WebSocketServer } from "ws";
 
@@ -64,11 +76,12 @@ function createWebuiClientRegistration(deps) {
 }
 
 // src/webui-server/connection-handler.ts
+import { deriveSessionAgents } from "@wrongstack/core/storage";
+import { buildReplayPayload, decodeProtocolFrame } from "@wrongstack/webui-protocol";
 import {
   createConnectionLifecycle,
   verifyClient as verifyWsClient
 } from "@wrongstack/webui-server";
-import { buildReplayPayload, decodeProtocolFrame } from "@wrongstack/webui-protocol";
 function createConnectionHandler(deps) {
   const clientHandlers = [
     deps.goalHandler,
@@ -139,19 +152,46 @@ function createConnectionHandler(deps) {
     send: deps.send,
     sessionPayload: deps.sessionPayload,
     rateLimitMax: deps.rateLimitMax,
-    onClose: (_ws, client) => {
-      if (client?.sessionId) deps.abortControllers.delete(client.sessionId);
-    },
+    // NOTE — a closed SOCKET is not a stopped run.
+    //
+    // This used to `abortControllers.delete(client.sessionId)` — a delete
+    // WITHOUT an abort, and only for the tab this connection last acted on.
+    // Both halves were wrong. The run kept going while `isRunActive` reported
+    // `false`, so `session.delete` would happily unlink the journal a live run
+    // was still appending to, and the next `user_message` claimed a second
+    // lock for the same session and hit `Agent.run() is already in progress`.
+    // The other three declared tabs were never touched at all.
+    //
+    // Doing nothing is the correct behaviour: a background run outlives the
+    // tab that started it (the same invariant `retireUndisplayedSessions`
+    // honours), and the run's own `finally` releases the lock when it unwinds.
+    // A page that comes back is told what is still running by
+    // `session.run_state`; a browser that never comes back drains its
+    // unanswerable permission prompts through the last-client drain in
+    // `connection-lifecycle.ts`, which lets a wedged run finish and release.
+    //
+    // So there is deliberately NO `onClose` here.
     buildInitialPayload: async () => {
       const payload = { ...await deps.buildSessionStartPayload({}, deps.needsSetup) };
+      try {
+        const open = deps.openSessionIds?.();
+        if (open) payload["openSessionIds"] = [.../* @__PURE__ */ new Set([...open, deps.currentSessionId()])];
+      } catch {
+        console.debug("[WebUI] Failed to list open sessions");
+      }
+      let replayEvents;
       try {
         const replay = await deps.loadReplay?.();
-        if (replay) Object.assign(payload, buildReplayPayload(replay));
+        if (replay) {
+          Object.assign(payload, buildReplayPayload(replay));
+          replayEvents = replay.events;
+        }
       } catch {
         console.debug("[WebUI] Failed to load replay");
       }
       try {
-        const sessions = await deps.loadAgentSessions?.();
+        const roster = deriveSessionAgents(replayEvents ?? []);
+        const sessions = roster.length > 0 ? await deps.loadAgentSessions?.(roster.map((agent) => agent.agentId)) : [];
         if (sessions?.length) payload["agentSessions"] = sessions;
       } catch {
         console.debug("[WebUI] Failed to load agent sessions");
@@ -755,6 +795,9 @@ function createPrefsSeeding(opts) {
     if (payload["modelMatrix"] && typeof payload["modelMatrix"] === "object" && !Array.isArray(payload["modelMatrix"])) {
       patchLiveAppConfig({ modelMatrix: payload["modelMatrix"] });
     }
+    if (payload["modelTiers"] && typeof payload["modelTiers"] === "object" && !Array.isArray(payload["modelTiers"])) {
+      patchLiveAppConfig({ modelTiers: payload["modelTiers"] });
+    }
     if (!opts.profileConfigPath) return;
     const globalRoot = opts.globalConfigPath ? path4.dirname(opts.globalConfigPath) : path4.dirname(opts.profileConfigPath);
     const vault = new DefaultSecretVault2({ keyFile: path4.join(globalRoot, ".key") });
@@ -780,7 +823,7 @@ function createPrefsSeeding(opts) {
     );
   };
   return {
-    prefSnapshot: () => snapshotPrefs(opts.agent.ctx.meta),
+    prefSnapshot: (meta) => snapshotPrefs(meta ?? opts.agent.ctx.meta),
     persistPrefs
   };
 }
@@ -792,7 +835,9 @@ import { SkillInstaller } from "@wrongstack/core/skills";
 import { PromptUsageStore } from "@wrongstack/core/storage";
 import { resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
 import {
-  createMailboxRouteHandlers
+  createChimeraRouteHandlers,
+  createMailboxRouteHandlers,
+  rebuildSystemPrompt
 } from "@wrongstack/webui-server";
 function createWebuiRouteContexts({
   opts,
@@ -807,10 +852,17 @@ function createWebuiRouteContexts({
   persistPrefs,
   pendingConfirms,
   abortControllers,
-  getAbortController,
-  clearAbortController,
+  getSessionAgent,
+  peekSessionAgent,
+  isSessionLive,
+  getForegroundSession,
+  setForegroundSession,
+  clients,
+  onSessionsUndisplayed,
+  stopSessionFleet,
   send,
-  broadcast
+  broadcast,
+  broadcastEveryone
 }) {
   const brainCtx = {
     brainSettings: opts.brainSettings,
@@ -823,6 +875,14 @@ function createWebuiRouteContexts({
   const introspectionConfigStore = opts.agent.container?.safeResolve?.(TOKENS2.ConfigStore);
   const introspectionCtx = {
     agent: opts.agent,
+    // Answer `diag.get` / `stats.get` / `side_effects.list` from the agent that
+    // owns the ASKING session. `opts.agent` is the leader, i.e. whichever tab
+    // the runtime last switched to, so a background tab asking for its own
+    // stats got the foreground's numbers stamped with the foreground's id —
+    // which the browser's session filter then dropped, leaving the panel blank.
+    // Read path, so `peek` first: `getAgent` creates, and materialising an
+    // agent for a stale id can evict a live tab's.
+    getAgent: (sessionId) => peekSessionAgent?.(sessionId) ?? (sessionId ? getSessionAgent(sessionId) : opts.agent),
     modelsRegistry: opts.modelsRegistry,
     configStore: introspectionConfigStore,
     getConfig: () => {
@@ -863,10 +923,10 @@ function createWebuiRouteContexts({
       skillsPaths?.promptUsage ?? path5.join(profileDir, "prompt-usage.json")
     )
   };
-  const designCtx = {
+  const designCtx = (sessionId) => ({
     projectRoot: skillsProjectRoot,
-    agentMeta: opts.agent.ctx
-  };
+    agentMeta: (sessionId ? getSessionAgent(sessionId)?.ctx : void 0) ?? opts.agent.ctx
+  });
   const agentConfigCtx = {
     agent: opts.agent,
     modeStore: opts.modeStore,
@@ -881,31 +941,86 @@ function createWebuiRouteContexts({
     broadcast,
     log: (m) => console.log(m)
   };
+  const promptProjectRoot = () => opts.projectRoot ?? opts.agent.ctx.projectRoot ?? "";
+  const metaForSession = (sessionId) => (sessionId ? getSessionAgent(sessionId)?.ctx.meta : void 0) ?? opts.agent.ctx.meta;
   const prefsCtx = {
     meta: opts.agent.ctx.meta,
-    snapshot: prefSnapshot,
+    metaFor: metaForSession,
+    snapshot: (sessionId) => prefSnapshot(sessionId ? metaForSession(sessionId) : void 0),
     persist: persistPrefs,
     setYolo: opts.onYoloSwitch,
     setAutonomy: opts.onAutonomySwitch,
     applyWrongProxyPrefs: opts.onWrongProxyPrefsChange,
     pendingConfirms,
     configStore: opts.agent.container?.safeResolve?.(TOKENS2.ConfigStore),
+    systemPrompt: {
+      paths: () => {
+        const wpaths = resolveWstackPaths3({ projectRoot: promptProjectRoot(), globalRoot });
+        return {
+          globalDir: wpaths.globalInstructions,
+          projectDir: wpaths.inProjectInstructions
+        };
+      },
+      profileConfigPath,
+      current: () => opts.appConfig?.systemPrompt?.variant ?? "default",
+      // Patch the live config before rebuilding — `persistPrefs` writes the
+      // file, and the builder reads the variant off the in-memory object.
+      applyVariant: async (variant, sessionId) => {
+        if (opts.appConfig) {
+          opts.appConfig = {
+            ...opts.appConfig,
+            systemPrompt: { ...opts.appConfig.systemPrompt ?? {}, variant }
+          };
+        }
+        const tools = opts.agent.tools;
+        if (!tools || !opts.appConfig) return;
+        const targetCtx = sessionId ? getSessionAgent(sessionId).ctx : opts.agent.ctx;
+        targetCtx.meta["systemPromptVariant"] = variant;
+        await rebuildSystemPrompt(
+          {
+            modeStore: opts.modeStore,
+            memoryStore: opts.memoryStore,
+            skillLoader: opts.skillLoader,
+            modelCapabilities: {
+              maxContextTokens: opts.agent.ctx.provider?.capabilities?.maxContext,
+              supportsTools: !!opts.agent.ctx.provider?.capabilities?.tools,
+              supportsVision: !!opts.agent.ctx.provider?.capabilities?.vision,
+              supportsReasoning: !!opts.agent.ctx.provider?.capabilities?.reasoning
+            },
+            context: targetCtx,
+            toolRegistry: tools,
+            getConfig: () => opts.appConfig,
+            projectRoot: promptProjectRoot(),
+            globalRoot,
+            container: opts.agent.container
+          },
+          typeof targetCtx.meta["mode"] === "string" ? targetCtx.meta["mode"] : "default"
+        );
+      }
+    },
     send,
     broadcast
   };
   const projectsCtx = {
     opts,
+    getForegroundSession,
+    setForegroundSession,
     abortControllers,
+    // Switching projects re-roots the server, so every conversation's run
+    // has to stop — there is no single "legacy" run to cancel here. The name
+    // is the shared context's; this host answers it with the only registry it
+    // has, one controller per tab. It used to read a process-wide controller
+    // that nothing ever set, so the teardown ran on nothing.
     abortLegacyRun: () => {
-      const controller = getAbortController();
-      if (controller) {
-        controller.abort();
-        clearAbortController();
-      }
+      for (const controller of abortControllers.values()) controller.abort();
+      abortControllers.clear();
     },
     buildSessionStart: (overrides) => buildSessionStartPayload(overrides),
     send,
     broadcast,
+    // A project switch re-roots the whole server; it is the one announcement
+    // that must reach connections which are displaying something else.
+    ...broadcastEveryone ? { broadcastEveryone } : {},
     log: (m) => console.log(m)
   };
   const mailboxRoutes = createMailboxRouteHandlers({
@@ -913,18 +1028,53 @@ function createWebuiRouteContexts({
     getGlobalRoot: () => opts.globalConfigPath ? path5.dirname(opts.globalConfigPath) : "",
     events: opts.events
   });
+  const chimeraRoutes = createChimeraRouteHandlers({
+    // Same lazily-resolved layout the mailbox routes read roots through:
+    // projectDir is the per-project WrongStack home where review-reports.jsonl
+    // lives. A project switch re-roots it, hence the getter.
+    projectDir: () => resolveWstackPaths3({
+      projectRoot: opts.projectRoot ?? opts.agent.ctx.projectRoot ?? "",
+      globalRoot: opts.globalConfigPath ? path5.dirname(opts.globalConfigPath) : ""
+    }).projectDir,
+    send,
+    log: (m) => console.warn(m)
+  });
   const sessionsCtx = {
     opts,
     buildSessionStart: (overrides) => buildSessionStartPayload(overrides),
     getCustomModeStore,
+    // Session transitions must re-point the TARGET session's context, not the
+    // leader's — resuming tab 2 was rewriting the context tab 1 ran in.
+    getAgent: getSessionAgent,
+    // Non-creating peek for the hasSession ownership gate.
+    ...peekSessionAgent ? { peekAgent: peekSessionAgent } : {},
+    // Session-keyed, so "is this tab running" is answered per tab and not
+    // "is anything running in this process".
+    isRunActive: (sessionId) => sessionId ? abortControllers.has(sessionId) : abortControllers.size > 0,
+    isSessionLive,
+    // A replayed session brings its own fleet back: the roster comes from that
+    // session's journal, the bodies from here. Scoped by id, because the
+    // transcripts directory is shared by every session of the project.
+    ...opts.agentTranscripts ? {
+      loadAgentSessions: async (subagentIds) => await opts.agentTranscripts?.loadSessionsFromDisk(subagentIds) ?? []
+    } : {},
+    getForegroundSession,
+    setForegroundSession,
+    clients,
+    onSessionsUndisplayed,
     send,
     broadcast,
     log: (m) => console.log(m)
   };
   const connectionCtx = {
     agent: opts.agent,
+    getAgent: getSessionAgent,
+    // Non-creating peek for the hasSession ownership gate (background-tab
+    // requests are legitimate; arbitrary strings are not).
+    ...peekSessionAgent ? { peekAgent: peekSessionAgent } : {},
     abortControllers,
     pendingConfirms,
+    ...stopSessionFleet ? { stopSessionFleet } : {},
     send,
     broadcast,
     log: (m) => console.log(m)
@@ -939,6 +1089,7 @@ function createWebuiRouteContexts({
     prefsCtx,
     projectsCtx,
     mailboxRoutes,
+    chimeraRoutes,
     sessionsCtx,
     connectionCtx
   };
@@ -958,6 +1109,9 @@ import {
 // src/webui-server/session-start-payload.ts
 function createSessionStartPayloadBuilder(deps) {
   return async function buildSessionStartPayload(overrides, needsSetup = false) {
+    const targetSessionId = typeof overrides?.["sessionId"] === "string" && overrides["sessionId"] ? overrides["sessionId"] : deps.agent.ctx.session?.id ?? deps.session.id;
+    const ctx = deps.getSessionContext?.(targetSessionId) ?? deps.agent.ctx;
+    const startedAt = typeof ctx.session?.startedAt === "string" && ctx.session.startedAt.length > 0 ? ctx.session.startedAt : void 0;
     let maxContext = 0;
     let inputCost = 0;
     let outputCost = 0;
@@ -965,37 +1119,33 @@ function createSessionStartPayloadBuilder(deps) {
     const updateInfo = deps.updateInfo;
     try {
       if (deps.modelsRegistry) {
-        const m = await deps.modelsRegistry.getModel(
-          deps.agent.ctx.provider.id,
-          deps.agent.ctx.model
-        );
+        const m = await deps.modelsRegistry.getModel(ctx.provider.id, ctx.model);
         const registryMax = m?.capabilities.maxContext;
-        maxContext = registryMax ?? deps.agent.ctx.provider.capabilities?.maxContext ?? 0;
+        maxContext = registryMax ?? ctx.provider.capabilities?.maxContext ?? 0;
         const rates = getCostRates(m);
         inputCost = rates.input;
         outputCost = rates.output;
         cacheReadCost = rates.cacheRead;
       } else {
-        maxContext = deps.agent.ctx.provider.capabilities?.maxContext ?? 0;
+        maxContext = ctx.provider.capabilities?.maxContext ?? 0;
       }
     } catch {
     }
-    const lastInputTokens = typeof deps.agent.ctx.lastRequestTokens === "number" && deps.agent.ctx.lastRequestTokens > 0 ? deps.agent.ctx.lastRequestTokens : 0;
+    const lastInputTokens = typeof ctx.lastRequestTokens === "number" && ctx.lastRequestTokens > 0 ? ctx.lastRequestTokens : 0;
     return {
-      sessionId: deps.agent.ctx.session?.id ?? deps.session.id,
-      model: deps.agent.ctx.model,
-      provider: deps.agent.ctx.provider.id,
+      sessionId: targetSessionId,
+      ...startedAt ? { startedAt } : {},
+      model: ctx.model,
+      provider: ctx.provider.id,
       mode: deps.modeId ?? "default",
       projectName: deps.projectRoot ? path6.basename(deps.projectRoot) : void 0,
       // Frontend reads `projectRoot` from session.start (ws-handlers setEnv) —
       // omitting it left the store's projectRoot empty after a project switch.
-      projectRoot: deps.projectRoot ?? deps.agent.ctx.projectRoot ?? "",
-      cwd: deps.projectRoot ?? deps.agent.ctx.projectRoot ?? "",
+      projectRoot: deps.projectRoot ?? ctx.projectRoot ?? "",
+      cwd: deps.projectRoot ?? ctx.projectRoot ?? "",
       needsSetup,
       // true when provider/model not configured and running in --webui mode
-      contextMode: String(
-        deps.agent.ctx.meta?.["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID
-      ),
+      contextMode: String(ctx.meta?.["contextWindowMode"] ?? DEFAULT_CONTEXT_WINDOW_MODE_ID),
       maxContext,
       inputCost,
       outputCost,
@@ -1013,6 +1163,7 @@ function createSessionStartPayloadBuilder(deps) {
 }
 
 // src/webui-server/setup-events.ts
+import { mailboxSessionTag } from "@wrongstack/core/coordination";
 import {
   createEternalSubscription,
   setupEvents as setupCanonicalEvents
@@ -1024,7 +1175,14 @@ function createSetupEvents(deps) {
     const budget = deps.getFleetBudget?.() ?? null;
     deps.broadcast({
       type: "fleet.concurrency_update",
-      payload: deps.sessionPayload({
+      // Deliberately UNSTAMPED. The spawn/concurrency budget is one ceiling
+      // for the whole process — every tab draws from it and the client keeps
+      // it in a single global store — so this is a project-wide fact, not a
+      // conversation's. Stamping it with the runtime's session made it a
+      // conversation's by accident: `clientWantsSession` then dropped it for
+      // any page whose declared tabs did not include that session, and the
+      // fleet gauges froze the moment the boot tab was closed.
+      payload: {
         fleetConcurrency: budget?.activeAgents ?? fleetConcurrency,
         fleetConcurrencyMax: budget?.maxConcurrent ?? fleetConcurrencyMax,
         ...budget ? {
@@ -1037,7 +1195,7 @@ function createSetupEvents(deps) {
           checkpointMaxSpawns: budget.checkpointMaxSpawns,
           ceilingMismatch: budget.ceilingMismatch
         } : {}
-      })
+      }
     });
   };
   return function setupEvents() {
@@ -1046,7 +1204,11 @@ function createSetupEvents(deps) {
     const maxIterations = deps.agent.ctx?.meta?.["maxIterations"];
     const disposeCanonical = setupCanonicalEvents({
       events: deps.events,
-      broadcast: (_clients, message) => deps.broadcast(message),
+      // The third argument is not decoration: it names the tab that OWNS a
+      // subagent, and the frames that pass it carry the subagent's own
+      // session on the payload. Dropping it here routed every subagent
+      // codemap frame at a session no tab subscribes to.
+      broadcast: (_clients, message, targetSessionId) => targetSessionId !== void 0 ? deps.broadcast(message, targetSessionId) : deps.broadcast(message),
       clients: deps.getClients(),
       config: {
         tools: {
@@ -1054,6 +1216,7 @@ function createSetupEvents(deps) {
         }
       },
       context: deps.agent.ctx,
+      ...deps.sessionContext ? { sessionContext: deps.sessionContext } : {},
       pendingConfirms: deps.pendingConfirms,
       globalConfigPath: deps.globalConfigPath,
       onFleetBroadcaster: deps.onFleetBroadcaster,
@@ -1071,7 +1234,7 @@ function createSetupEvents(deps) {
       type: "subagent.event",
       payload: deps.sessionPayload({
         kind: "leader_updated",
-        subagentId: "leader",
+        subagentId: `leader@${mailboxSessionTag(deps.currentSessionId())}`,
         isLeader: true,
         name: "Leader",
         status: "running"
@@ -1115,96 +1278,8 @@ import {
   createStreamCoalescer
 } from "@wrongstack/webui-server";
 
-// src/webui-server/terminal-log-view.ts
-import { format } from "node:util";
-var DEFAULT_BUFFER_LINES = 200;
-var MUTED_LEVELS = ["log", "info", "debug"];
-var FORWARDED_LEVELS = ["warn", "error"];
-var DISABLED = {
-  enabled: false,
-  mutedCount: 0,
-  recent: () => [],
-  stop: () => {
-  }
-};
-function envVerbose() {
-  for (const name of ["WEBUI_VERBOSE", "WRONGSTACK_WEBUI_VERBOSE"]) {
-    const value = process.env[name]?.trim().toLowerCase();
-    if (value === "1" || value === "true" || value === "yes" || value === "on") return true;
-  }
-  return false;
-}
-function startQuietSurfaceConsole(options = {}) {
-  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
-  const verbose = options.verbose ?? envVerbose();
-  if (!isTTY || verbose) return DISABLED;
-  const bufferLines = Math.max(1, Math.trunc(options.bufferLines ?? DEFAULT_BUFFER_LINES));
-  const target = options.consoleTarget ?? console;
-  const muted = [];
-  let mutedCount = 0;
-  let stopped = false;
-  let lastLine = null;
-  let lastEmit = null;
-  let repeats = 0;
-  const originals = {
-    log: target.log,
-    info: target.info,
-    warn: target.warn,
-    error: target.error,
-    debug: target.debug
-  };
-  const wrappers = {};
-  const flushRepeats = () => {
-    if (repeats === 0 || !lastEmit) return;
-    const count = repeats;
-    repeats = 0;
-    lastEmit.call(target, `  \u2191 previous line repeated ${count}\xD7`);
-  };
-  for (const level of MUTED_LEVELS) {
-    const wrapper = (...args) => {
-      mutedCount += 1;
-      muted.push(format(...args));
-      if (muted.length > bufferLines) muted.shift();
-    };
-    wrappers[level] = wrapper;
-    target[level] = wrapper;
-  }
-  for (const level of FORWARDED_LEVELS) {
-    const original = originals[level];
-    const wrapper = (...args) => {
-      const line = format(...args);
-      if (line === lastLine) {
-        repeats += 1;
-        return;
-      }
-      flushRepeats();
-      lastLine = line;
-      lastEmit = original;
-      original.apply(target, args);
-    };
-    wrappers[level] = wrapper;
-    target[level] = wrapper;
-  }
-  return {
-    enabled: true,
-    get mutedCount() {
-      return mutedCount;
-    },
-    recent: () => [...muted],
-    stop: () => {
-      if (stopped) return;
-      stopped = true;
-      flushRepeats();
-      for (const level of Object.keys(originals)) {
-        if (target[level] === wrappers[level]) target[level] = originals[level];
-      }
-    }
-  };
-}
-
 // src/webui-server.ts
 async function runWebUI(opts) {
-  const terminalLogView = startQuietSurfaceConsole();
   const trustBoundary = opts.trustBoundary ?? createCompatibilityTrustBoundary({ policyId: "cli-webui-trusted-host-compat-v1" });
   const host = opts.host ?? process.env["WEBUI_HOST"] ?? process.env["WS_HOST"] ?? "127.0.0.1";
   const publicUrl = opts.publicUrl ?? process.env["WEBUI_PUBLIC_URL"];
@@ -1213,6 +1288,11 @@ async function runWebUI(opts) {
   const surface = opts.surface ?? "webui";
   const surfaceDefaults = surface === "simpleui" ? { http: 3466 } : { http: 3456 };
   const requestedHttpPort = opts.httpPort ?? opts.port ?? surfaceDefaults.http;
+  const terminalLogView = startTerminalDashboard({
+    title: surface === "simpleui" ? "SimpleUI" : "WebUI",
+    quiet: !envFlag("WEBUI_LOGS"),
+    getUrl: () => `http://${host}:${httpPort}`
+  });
   const strictPort = opts.strictPort ?? isStrictPort();
   let httpPort = requestedHttpPort;
   if (!strictPort) {
@@ -1225,7 +1305,6 @@ async function runWebUI(opts) {
   const clients = /* @__PURE__ */ new Map();
   const pendingConfirms = /* @__PURE__ */ new Map();
   const secretScrubber = new DefaultSecretScrubber();
-  let abortController = null;
   const abortControllers = /* @__PURE__ */ new Map();
   const profileDir = path7.dirname(profileConfigPath);
   let customModeStoreP = null;
@@ -1274,7 +1353,24 @@ async function runWebUI(opts) {
   }
   const { prefSnapshot, persistPrefs } = createPrefsSeeding(opts);
   const sessionStartedAt = Date.now();
-  const buildSessionStartPayload = createSessionStartPayloadBuilder(opts);
+  let sessionAgentsRef;
+  const buildSessionStartPayload = createSessionStartPayloadBuilder({
+    ...opts,
+    // Read through to the live `opts`, do NOT snapshot: `projects.select`
+    // re-roots the host by assigning `opts.projectRoot` / `opts.session` on
+    // this very object. A spread copy froze both at boot, so every
+    // `session.start` broadcast after a project switch still announced the
+    // previous project's root — the switch looked like it had not happened.
+    get projectRoot() {
+      return opts.projectRoot;
+    },
+    get session() {
+      return opts.session;
+    },
+    // `peek`, never `get`: building a payload must not materialise an agent
+    // for a session id that arrived from a stale browser tab.
+    getSessionContext: (sessionId) => sessionAgentsRef?.peek(sessionId)?.ctx
+  });
   const { register: registerWebuiClient, unregister: unregisterWebuiClient } = createWebuiClientRegistration({
     projectRoot: opts.projectRoot,
     appConfig: opts.appConfig,
@@ -1282,19 +1378,23 @@ async function runWebUI(opts) {
     hqSessionId: opts.session.id,
     getSessionId: () => opts.agent.ctx.session?.id ?? opts.session.id,
     hqControl: {
+      // HQ speaks for the LEADER — the boot session, the one it registered
+      // itself under (`hqSessionId`) — not for whatever else the browser
+      // has open. This used to abort every controller in the map and clear
+      // it, so a remote "interrupt" issued against the leader also killed
+      // the three other tabs' in-flight runs. Deleting the entries was
+      // wrong on its own terms too: the run's own `end()` owns removal, and
+      // clearing early makes `isRunActive` lie to every tab still running.
       interruptLeader: () => {
-        let aborted = false;
-        if (abortController) {
-          abortController.abort();
-          abortController = null;
-          aborted = true;
-        }
-        for (const c of abortControllers.values()) {
-          c.abort();
-          aborted = true;
+        const leaderId = opts.session.id;
+        const controller = abortControllers.get(leaderId);
+        if (!controller) return false;
+        controller.abort();
+        try {
+          void Promise.resolve(opts.stopSessionFleet?.(leaderId)).catch(() => void 0);
+        } catch {
         }
-        abortControllers.clear();
-        return aborted;
+        return true;
       },
       allowRunCommand: () => opts.hqAllowExec === true
     }
@@ -1343,6 +1443,16 @@ async function runWebUI(opts) {
     ...opts.vectorMemoryModelCacheDir ? { vectorMemoryModelCacheDir: opts.vectorMemoryModelCacheDir } : {}
   });
   const wss = httpServer ? new WebSocketServer({ server: httpServer.server, maxPayload: 20 * 1024 * 1024 }) : new WebSocketServer({ port: httpPort, host, maxPayload: 20 * 1024 * 1024 });
+  wss.on("error", (err) => {
+    console.error(
+      JSON.stringify({
+        level: "error",
+        event: "webui_server.error",
+        message: err instanceof Error ? err.message : String(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  });
   if (httpServer) {
     const boundPort = surface === "simpleui" ? await startDeferredHttpListen({
       server: httpServer.server,
@@ -1381,7 +1491,8 @@ async function runWebUI(opts) {
       `[WebUI] Frontend not served (run \`pnpm --filter @wrongstack/webui build\`). WS bridge still active on ws://${host}:${httpPort}.`
     );
   }
-  const currentSessionId = () => opts.agent.ctx.session?.id ?? opts.session.id;
+  let foregroundSession = opts.agent.ctx.session ?? opts.session;
+  const currentSessionId = () => foregroundSession.id;
   const registryBaseDir = globalRoot;
   let webuiInstanceRegistered = false;
   if (opts.projectRoot) {
@@ -1433,6 +1544,7 @@ async function runWebUI(opts) {
     flushAllStreamBuffers
   } = createStreamCoalescer({ broadcast, sessionPayload });
   const setupEvents = createSetupEvents({
+    sessionContext: (sessionId) => sessionAgentsRef?.peek(sessionId)?.ctx,
     events: opts.events,
     agent: opts.agent,
     subscribeEternalIteration: opts.subscribeEternalIteration,
@@ -1471,6 +1583,90 @@ async function runWebUI(opts) {
     broadcast,
     broadcastSaved: (providers) => embeddedProviderOperations.broadcastSaved(providers)
   });
+  const sessionAgents = createSessionAgentRegistry({
+    template: opts.agent,
+    ...opts.modelsRegistry ? { modelsRegistry: opts.modelsRegistry } : {},
+    isRunActive: (sessionId) => abortControllers.has(sessionId),
+    // A tab that is still on screen must outlive one that was closed, whatever
+    // order their agents were created in.
+    isDisplayed: (sessionId) => {
+      for (const client of clients.values()) {
+        if (client.sessionId === sessionId) return true;
+        if (client.sessionIds?.has(sessionId) === true) return true;
+      }
+      return false;
+    }
+  });
+  sessionAgentsRef = sessionAgents;
+  const stopLiveStatusLogger = startWebUILiveStatusLogger({
+    events: opts.events,
+    dashboard: terminalLogView,
+    getSessionList: () => {
+      const ids = /* @__PURE__ */ new Set();
+      for (const client of clients.values()) {
+        if (client.sessionId) ids.add(client.sessionId);
+        for (const id of client.sessionIds ?? []) ids.add(id);
+      }
+      const currentId = opts.agent.ctx.session?.id ?? opts.session.id;
+      if (ids.size === 0 && currentId) ids.add(currentId);
+      return Array.from(ids).map((id) => {
+        const ctx = sessionAgentsRef?.peek(id)?.ctx;
+        return {
+          id,
+          model: ctx?.model ?? opts.agent.ctx.model ?? "",
+          provider: ctx?.provider?.id ?? opts.agent.ctx.provider?.id ?? "",
+          isRunning: abortControllers.has(id)
+        };
+      });
+    }
+  });
+  const releaseSessionSalvage = addFatalSalvageHook(() => {
+    try {
+      sessionAgents.flushAllSync();
+    } catch {
+    }
+  });
+  const retireUndisplayedSessions = (sessionIds) => {
+    for (const sessionId of sessionIds) {
+      if (!sessionId || sessionId === opts.session.id) continue;
+      if (sessionId === foregroundSession.id) continue;
+      const orphaned = resolvePendingConfirmsForSession(pendingConfirms, sessionId);
+      if (orphaned > 0) {
+        console.log(
+          JSON.stringify({
+            level: "warn",
+            event: "webui.confirm_orphaned_by_tab_close",
+            sessionId,
+            count: orphaned,
+            message: `Denied ${orphaned} unanswerable permission prompt(s) for closed session ${sessionId}.`
+          })
+        );
+      }
+      if (abortControllers.has(sessionId)) continue;
+      opts.onSessionRetired?.(sessionId);
+      const agent = sessionAgents.peek(sessionId);
+      if (!agent || agent === opts.agent) continue;
+      void sessionAgents.endAndClose(sessionId);
+    }
+  };
+  const stopEmptySessionCleanup = opts.sessionStore ? scheduleOwnerlessEmptySessionCleanup({
+    getSessionStore: () => opts.sessionStore,
+    getActiveSessionId: () => foregroundSession.id,
+    getActiveSessionIds: () => collectDisplayedSessionIds({ getSession: () => foregroundSession, clients }),
+    // A run outlives the tab that started it, and a turn that has not
+    // written its first record yet looks exactly like a session nobody
+    // ever used.
+    hasParticipants: (sessionId) => abortControllers.has(sessionId),
+    refreshSessions: async () => {
+      const list = await opts.sessionStore?.list(200);
+      if (!list) return;
+      broadcastEveryone({
+        type: "sessions.list",
+        payload: { sessions: toSessionHistoryEntries(list, foregroundSession.id) }
+      });
+    },
+    logger: consoleLogger
+  }) : null;
   const routeContexts = createWebuiRouteContexts({
     opts,
     profileConfigPath,
@@ -1484,12 +1680,19 @@ async function runWebUI(opts) {
     persistPrefs,
     pendingConfirms,
     abortControllers,
-    getAbortController: () => abortController,
-    clearAbortController: () => {
-      abortController = null;
+    getSessionAgent: (sessionId) => sessionAgents.get(sessionId),
+    peekSessionAgent: (sessionId) => sessionAgents.peek(sessionId),
+    onSessionsUndisplayed: retireUndisplayedSessions,
+    isSessionLive: (sessionId) => sessionAgents.isLive(sessionId),
+    getForegroundSession: () => foregroundSession,
+    setForegroundSession: (next) => {
+      foregroundSession = next;
     },
+    clients,
+    ...opts.stopSessionFleet ? { stopSessionFleet: opts.stopSessionFleet } : {},
     send,
-    broadcast
+    broadcast,
+    broadcastEveryone
   });
   const kanbanHostRoutes = createCliKanbanHostRoutes({
     opts,
@@ -1526,6 +1729,7 @@ async function runWebUI(opts) {
     prefsCtx: routeContexts.prefsCtx,
     projectCtx: routeContexts.projectsCtx,
     mailboxRoutes: routeContexts.mailboxRoutes,
+    chimeraRoutes: routeContexts.chimeraRoutes,
     sessionCtx: routeContexts.sessionsCtx,
     conversationCtx: routeContexts.connectionCtx,
     goalHandler,
@@ -1579,12 +1783,11 @@ async function runWebUI(opts) {
         send,
         sessionPayload,
         handleMessage,
-        abortControllers,
         pendingConfirms,
         buildSessionStartPayload,
         loadReplay: async () => {
           const activeSession = opts.agent.ctx.session ?? opts.session;
-          await activeSession.flush().catch(() => void 0);
+          await activeSession.flush();
           if (opts.sessionStore) {
             const data = await opts.sessionStore.load(activeSession.id);
             return { messages: data.messages, events: data.events, usage: data.usage };
@@ -1592,27 +1795,17 @@ async function runWebUI(opts) {
           const usage = opts.agent.ctx.tokenCounter.total();
           return { messages: opts.agent.ctx.messages, usage };
         },
-        loadAgentSessions: async () => await opts.agentTranscripts?.loadSessionsFromDisk() ?? [],
+        loadAgentSessions: async (subagentIds) => await opts.agentTranscripts?.loadSessionsFromDisk(subagentIds) ?? [],
+        // What this process is actually holding right now. The browser
+        // reconciles its persisted tab strip against it, so a restarted server
+        // is not dressed in the previous run's tabs.
+        openSessionIds: () => sessionAgents.ids(),
         needsSetup: opts.needsSetup ?? false
       })
     );
-    wss.on("error", (err) => {
-      console.error(
-        JSON.stringify({
-          level: "error",
-          event: "webui_server.error",
-          message: err instanceof Error ? err.message : String(err),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
-      );
-    });
     signalShutdown = createWebuiShutdown({
       abortInFlight: () => {
         void embeddedAutoHealDispose?.();
-        if (abortController) {
-          abortController.abort();
-          abortController = null;
-        }
         for (const c of abortControllers.values()) c.abort();
         abortControllers.clear();
       },
@@ -1640,6 +1833,9 @@ async function runWebUI(opts) {
         }
       },
       disposeResources: async () => {
+        releaseSessionSalvage();
+        await stopEmptySessionCleanup?.dispose();
+        await sessionAgents.closeAll().catch(() => void 0);
         credentialWatcherClose?.();
         credentialWatcherClose = void 0;
         goalHandler.dispose();
@@ -1665,11 +1861,12 @@ async function runWebUI(opts) {
       pid: process.pid,
       registryBaseDir,
       onStopped: () => {
+        stopLiveStatusLogger();
         const muted = terminalLogView.mutedCount;
         terminalLogView.stop();
         if (muted > 0) {
           console.log(
-            `[WebUI] ${muted} progress line(s) kept out of this terminal \u2014 set WEBUI_VERBOSE=1 to see them.`
+            `[WebUI] ${muted} progress line(s) kept out of this terminal \u2014 set WEBUI_LOGS=1 to stream them.`
           );
         }
         opts.onExit?.();
@@ -1681,7 +1878,15 @@ async function runWebUI(opts) {
   function send(ws, msg) {
     sendSerialized(ws, JSON.stringify(msg));
   }
-  function broadcast(msg) {
+  function broadcast(msg, targetSessionId) {
+    const data = JSON.stringify(msg);
+    const payload = msg.payload;
+    const sessionId = targetSessionId ?? (payload && typeof payload === "object" && typeof payload.sessionId === "string" ? payload.sessionId : void 0);
+    for (const [ws, client] of clients) {
+      if (clientWantsSession(client, sessionId)) sendSerialized(ws, data);
+    }
+  }
+  function broadcastEveryone(msg) {
     const data = JSON.stringify(msg);
     for (const [ws] of clients) sendSerialized(ws, data);
   }
@@ -1693,4 +1898,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-I53IYBW4.js.map
+//# sourceMappingURL=webui-server-LZOEH7O6.js.map