@wrongstack/cli 1.0.19 → 1.0.26

package/dist/{webui-server-MRPGTTKL.js → webui-server-YTHLRFD2.js}

@@ -1,108 +1,30 @@
 import {
-  createKanbanRunMirror
-} from "./chunk-VCYZ3WZV.js";
+  createKanbanSupervisor
+} from "./chunk-R4QGL6GB.js";
 import {
   WEBUI_SESSION_CHILD_CAPABILITIES
-} from "./chunk-GPPRNAKW.js";
+} from "./chunk-ZMX5HRLI.js";
+import {
+  createKanbanRunMirror
+} from "./chunk-VCYZ3WZV.js";
 import {
   createHqCommandDispatcher,
   createProjectKanbanAssignHandler,
   createProjectKanbanTransitionHandler
-} from "./chunk-JY52HWL6.js";
+} from "./chunk-2EBVTYJR.js";
 import {
   startCliHqConnection
-} from "./chunk-CJTBLTS4.js";
+} from "./chunk-KJS5543T.js";
 import {
   CLI_VERSION
-} from "./chunk-XJXDOF63.js";
+} from "./chunk-F5DCFAKI.js";
 import {
   loadConfigProviders,
   mutateConfigProviders
-} from "./chunk-DR2OXU46.js";
+} from "./chunk-LUMETJFO.js";
 
-// src/webui-server.ts
-import * as path7 from "node:path";
-import { createCompatibilityTrustBoundary, DefaultSecretScrubber } from "@wrongstack/core/security";
-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,
-  createWebuiLeaderAutoWakeHost,
-  envFlag,
-  findFreePort,
-  findInstalledPackageJson,
-  isStrictPort,
-  resolveAuthToken,
-  resolvePendingConfirmsForSession,
-  scheduleOwnerlessEmptySessionCleanup,
-  sendSerialized,
-  stampDispatchSession,
-  startTerminalDashboard,
-  startWebUILiveStatusLogger,
-  toSessionHistoryEntries
-} from "@wrongstack/webui-server";
-import { verifyClient as verifyWsClient2 } from "@wrongstack/webui-server/server/ws-auth";
-import { WebSocketServer } from "ws";
-
-// src/webui-server/client-registration.ts
-import { mailboxSessionTag } from "@wrongstack/core/coordination";
-import { createWebuiClientPresence } from "@wrongstack/webui-server";
-function createWebuiClientRegistration(deps) {
-  const control = deps.hqControl;
-  return createWebuiClientPresence({
-    projectRoot: deps.projectRoot,
-    appConfig: deps.appConfig,
-    events: deps.events,
-    hqSessionId: deps.hqSessionId,
-    getSessionId: deps.getSessionId,
-    clientVersion: CLI_VERSION,
-    ...deps.listSessions ? { listSessions: deps.listSessions } : {},
-    ...deps.isSessionOwnedElsewhere ? { isSessionOwnedElsewhere: deps.isSessionOwnedElsewhere } : {},
-    ...deps.getSessionWriter ? { getSessionWriter: deps.getSessionWriter } : {},
-    startHqConnection: (options) => startCliHqConnection({
-      ...options,
-      capabilities: options.capabilities
-    }),
-    ...control ? {
-      createCommandHandler: (mailbox, approvals) => createHqCommandDispatcher({
-        steerMailbox: mailbox,
-        interruptLeader: control.interruptLeader,
-        allowRunCommand: control.allowRunCommand,
-        // Same registry the approval bridge publishes from, so every
-        // prompt HQ shows is one this handler can actually answer.
-        resolveApproval: (toolUseId, decision, sessionId) => approvals.resolve(toolUseId, decision, sessionId),
-        ...deps.projectRoot ? {
-          kanbanTransition: createProjectKanbanTransitionHandler(deps.projectRoot),
-          kanbanAssign: createProjectKanbanAssignHandler(deps.projectRoot)
-        } : {},
-        // The session HQ actually SHOWS for this client — the boot
-        // session the telemetry bridge publishes under and the only one
-        // `interruptLeader` speaks for. `getSessionId` follows whichever
-        // browser tab is in front, which is a different session HQ has
-        // no view of and cannot control.
-        sessionTag: () => mailboxSessionTag(deps.hqSessionId),
-        // The session HQ falls back to when a command names none — the
-        // boot tab. A command that DOES name one is honoured (and
-        // refused when this host no longer has it) via `ownsSession`.
-        sessionId: () => deps.hqSessionId,
-        ...control.ownsSession ? { ownsSession: control.ownsSession } : {},
-        ...control.spawnAgent ? { spawnAgent: control.spawnAgent } : {},
-        ...control.killFleet ? { killFleet: control.killFleet } : {},
-        ...control.terminateAgent ? { terminateAgent: control.terminateAgent } : {}
-      })
-    } : {}
-  });
-}
+// src/webui-server-lifecycle.ts
+import { toErrorMessage } from "@wrongstack/core/utils/error";
 
 // src/webui-server/connection-handler.ts
 import { deriveSessionAgents } from "@wrongstack/core/storage";
@@ -230,15 +152,406 @@ function createConnectionHandler(deps) {
   });
 }
 
+// src/webui-server/lifecycle.ts
+import {
+  announceWebuiReady,
+  createWebuiShutdown,
+  registerWebuiInstance,
+  registerWebuiSignalHandlers
+} from "@wrongstack/webui-server";
+
+// src/webui-server/logger-shim.ts
+var structuredLine = (level, message) => JSON.stringify({
+  level,
+  event: "webui.goal",
+  message,
+  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+});
+var consoleLogger = {
+  level: "debug",
+  error(msg, _ctx) {
+    console.error(structuredLine("error", msg));
+  },
+  warn(msg, _ctx) {
+    console.warn(structuredLine("warn", msg));
+  },
+  info(msg, _ctx) {
+    console.log(structuredLine("info", msg));
+  },
+  debug(msg, _ctx) {
+    console.debug(structuredLine("debug", msg));
+  },
+  trace(msg, _ctx) {
+    console.debug(structuredLine("trace", msg));
+  },
+  child(_bindings) {
+    return this;
+  }
+};
+
+// src/webui-server-lifecycle.ts
+function runWebuiServerLifecycle({
+  host,
+  httpPort,
+  setupEvents,
+  opts,
+  wsPort,
+  accessUrl,
+  wsToken,
+  webuiInstanceRegistered,
+  wss,
+  httpServer,
+  requireToken,
+  publicHostnames,
+  publicWsUrl,
+  clients,
+  currentSessionId,
+  goalHandler,
+  specsHandler,
+  sddBoardHandler,
+  sddWizardHandler,
+  worktreeHandler,
+  terminalHandler,
+  rateLimitMax,
+  send,
+  sessionPayload,
+  handleMessage,
+  pendingConfirms,
+  buildSessionStartPayload,
+  sessionAgents,
+  lifecycleState,
+  abortControllers,
+  flushAllStreamBuffers,
+  eventUnsubscribers,
+  releaseSessionSalvage,
+  autoWakeHost,
+  stopEmptySessionCleanup,
+  credentialWatcherClose,
+  kanbanRunMirror,
+  kanbanSupervisor,
+  stopKanbanSupervisorMemoryStats,
+  unregisterWebuiClient,
+  ipv6LoopbackServer,
+  registryBaseDir,
+  stopLiveStatusLogger,
+  terminalLogView
+}) {
+  const stopped = new Promise((resolve) => {
+    let listeningAnnounced = false;
+    const announceListening = () => {
+      if (listeningAnnounced) return;
+      listeningAnnounced = true;
+      console.log(`[WebUI] WebSocket server running on ws://${host}:${httpPort}`);
+      try {
+        setupEvents();
+        opts.onListening?.({
+          httpPort,
+          wsPort,
+          host,
+          url: accessUrl,
+          authToken: wsToken,
+          webuiInstanceRegistered
+        });
+      } catch (err) {
+        consoleLogger.error("setup_events_failed", { message: toErrorMessage(err) });
+      }
+    };
+    wss.on("listening", announceListening);
+    if (httpServer?.server.listening || wss.address()) queueMicrotask(announceListening);
+    wss.on(
+      "connection",
+      createConnectionHandler({
+        host,
+        wsToken,
+        requireToken,
+        publicHostnames,
+        publicWsUrl,
+        clients,
+        currentSessionId,
+        goalHandler,
+        specsHandler,
+        sddBoardHandler,
+        sddWizardHandler,
+        worktreeHandler,
+        terminalHandler,
+        rateLimitMax,
+        send,
+        sessionPayload,
+        handleMessage,
+        pendingConfirms,
+        buildSessionStartPayload,
+        loadReplay: async () => {
+          const activeSession = opts.agent.ctx.session ?? opts.session;
+          await activeSession.flush();
+          if (opts.sessionStore) {
+            const data = await opts.sessionStore.load(activeSession.id);
+            return { messages: data.messages, events: data.events, usage: data.usage };
+          }
+          const usage = opts.agent.ctx.tokenCounter.total();
+          return { messages: opts.agent.ctx.messages, usage };
+        },
+        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
+      })
+    );
+    lifecycleState.signalShutdown = createWebuiShutdown({
+      abortInFlight: () => {
+        void lifecycleState.embeddedAutoHealDispose?.();
+        for (const c of abortControllers.values()) c.abort();
+        abortControllers.clear();
+      },
+      unsubscribeEvents: () => {
+        flushAllStreamBuffers();
+        for (const unsub of eventUnsubscribers) unsub();
+      },
+      stopOwnedChildren: async () => {
+        try {
+          const { getProcessRegistry } = await import("@wrongstack/tools");
+          getProcessRegistry().killAll({ force: true, includeProtected: true });
+        } catch (err) {
+          console.debug(
+            `[webui-server] process-registry killAll failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        if (opts.mcpRegistry) {
+          try {
+            await opts.mcpRegistry.stopAll();
+          } catch (err) {
+            console.debug(
+              `[webui-server] mcpRegistry.stopAll failed: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
+        }
+      },
+      disposeResources: async () => {
+        releaseSessionSalvage();
+        autoWakeHost?.dispose();
+        await stopEmptySessionCleanup?.dispose();
+        await sessionAgents.closeAll().catch(() => void 0);
+        credentialWatcherClose?.();
+        credentialWatcherClose = void 0;
+        goalHandler.dispose();
+        sddBoardHandler.dispose();
+        worktreeHandler.dispose();
+        terminalHandler.dispose();
+        kanbanRunMirror?.dispose();
+        kanbanSupervisor?.dispose();
+        void stopKanbanSupervisorMemoryStats?.();
+        await lifecycleState.embeddedAutoHealDispose?.();
+        lifecycleState.embeddedAutoHealDispose = null;
+        unregisterWebuiClient();
+      },
+      closeClients: () => {
+        for (const [ws] of clients) ws.close();
+        clients.clear();
+      },
+      closeHttpServer: () => {
+        ipv6LoopbackServer?.close();
+        httpServer?.server.close();
+      },
+      wss,
+      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_LOGS=1 to stream them.`
+          );
+        }
+        opts.onExit?.();
+        resolve();
+      }
+    });
+    registerWebuiSignalHandlers(lifecycleState.signalShutdown);
+  });
+  return { stopped };
+}
+
+// src/webui-server.ts
+import * as path7 from "node:path";
+import { createCompatibilityTrustBoundary, DefaultSecretScrubber } from "@wrongstack/core/security";
+import {
+  addFatalSalvageHook,
+  startSharedHeapWatchdog,
+  wstackGlobalRoot
+} from "@wrongstack/core/utils";
+import {
+  buildWebUIAccessUrl,
+  clientWantsSession,
+  collectDisplayedSessionIds,
+  createCustomModeStore,
+  createEmbeddedMessageRouter,
+  createEmbeddedProviderOperations,
+  createSessionAgentRegistry,
+  createWebuiLeaderAutoWakeHost,
+  envFlag,
+  findFreePort,
+  findInstalledPackageJson,
+  isStrictPort,
+  resolveAuthToken,
+  resolvePendingConfirmsForSession,
+  scheduleOwnerlessEmptySessionCleanup,
+  sendSerialized,
+  stampDispatchSession,
+  startTerminalDashboard,
+  toSessionHistoryEntries,
+  webuiSessionFrameLog
+} from "@wrongstack/webui-server";
+import { verifyClient as verifyWsClient2 } from "@wrongstack/webui-server/server/ws-auth";
+import { WebSocketServer } from "ws";
+
+// src/webui-client-observability.ts
+import { startWebUILiveStatusLogger } from "@wrongstack/webui-server";
+
+// src/webui-server/client-registration.ts
+import { mailboxSessionTag } from "@wrongstack/core/coordination";
+import { createWebuiClientPresence } from "@wrongstack/webui-server";
+function createWebuiClientRegistration(deps) {
+  const control = deps.hqControl;
+  return createWebuiClientPresence({
+    projectRoot: deps.projectRoot,
+    appConfig: deps.appConfig,
+    events: deps.events,
+    hqSessionId: deps.hqSessionId,
+    getSessionId: deps.getSessionId,
+    clientVersion: CLI_VERSION,
+    ...deps.listSessions ? { listSessions: deps.listSessions } : {},
+    ...deps.isSessionOwnedElsewhere ? { isSessionOwnedElsewhere: deps.isSessionOwnedElsewhere } : {},
+    ...deps.getSessionWriter ? { getSessionWriter: deps.getSessionWriter } : {},
+    startHqConnection: (options) => startCliHqConnection({
+      ...options,
+      capabilities: options.capabilities
+    }),
+    ...control ? {
+      createCommandHandler: (mailbox, approvals) => createHqCommandDispatcher({
+        steerMailbox: mailbox,
+        interruptLeader: control.interruptLeader,
+        allowRunCommand: control.allowRunCommand,
+        // Same registry the approval bridge publishes from, so every
+        // prompt HQ shows is one this handler can actually answer.
+        resolveApproval: (toolUseId, decision, sessionId) => approvals.resolve(toolUseId, decision, sessionId),
+        ...deps.projectRoot ? {
+          kanbanTransition: createProjectKanbanTransitionHandler(deps.projectRoot),
+          kanbanAssign: createProjectKanbanAssignHandler(deps.projectRoot)
+        } : {},
+        // The session HQ actually SHOWS for this client — the boot
+        // session the telemetry bridge publishes under and the only one
+        // `interruptLeader` speaks for. `getSessionId` follows whichever
+        // browser tab is in front, which is a different session HQ has
+        // no view of and cannot control.
+        sessionTag: () => mailboxSessionTag(deps.hqSessionId),
+        // The session HQ falls back to when a command names none — the
+        // boot tab. A command that DOES name one is honoured (and
+        // refused when this host no longer has it) via `ownsSession`.
+        sessionId: () => deps.hqSessionId,
+        ...control.ownsSession ? { ownsSession: control.ownsSession } : {},
+        ...control.spawnAgent ? { spawnAgent: control.spawnAgent } : {},
+        ...control.killFleet ? { killFleet: control.killFleet } : {},
+        ...control.terminateAgent ? { terminateAgent: control.terminateAgent } : {}
+      })
+    } : {}
+  });
+}
+
+// src/webui-client-observability.ts
+function createEmbeddedClientRegistration(opts, clients, abortControllers, getSessionAgents) {
+  return createWebuiClientRegistration({
+    projectRoot: opts.projectRoot,
+    appConfig: opts.appConfig,
+    events: opts.events,
+    hqSessionId: opts.session.id,
+    getSessionId: () => opts.agent.ctx.session?.id ?? opts.session.id,
+    // One HQ session per open tab. The set is the same one the terminal
+    // panel lists: every session a connected browser is displaying.
+    listSessions: () => {
+      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);
+      }
+      return [...ids];
+    },
+    // `cli-main` already runs a tracker and a bridge for the boot session.
+    // Announcing it here too would put two trackers on one bus flushing the
+    // same agent list.
+    isSessionOwnedElsewhere: (sessionId) => sessionId === opts.session.id,
+    // The tab's own journal, so HQ takes its turns from the write path
+    // instead of tailing the file.
+    getSessionWriter: (sessionId) => getSessionAgents()?.peek(sessionId)?.ctx.session,
+    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.
+      // Every open tab is its own session with its own abort controller, so
+      // the command's session is the one that gets stopped. Falling back to
+      // the boot session keeps a dashboard that sends no session — every one
+      // before this existed — behaving exactly as before.
+      interruptLeader: (sessionId) => {
+        const leaderId = sessionId ?? 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 {
+        }
+        return true;
+      },
+      allowRunCommand: () => opts.hqAllowExec === true,
+      // A command naming a tab this process no longer holds is refused, not
+      // redirected onto the boot session: the operator picked a terminal,
+      // and steering a different one is worse than not steering at all.
+      ownsSession: (sessionId) => sessionId === opts.session.id || getSessionAgents()?.has(sessionId) === true
+    }
+  });
+}
+function startEmbeddedLiveStatusLogger(opts, clients, abortControllers, getSessionAgents, terminalLogView) {
+  return 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 = getSessionAgents()?.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)
+        };
+      });
+    }
+  });
+}
+
 // src/webui-server/credential-watcher.ts
 import { TOKENS } from "@wrongstack/core/kernel";
 import { watchProviderConfig } from "@wrongstack/core/storage";
-import { toErrorMessage } from "@wrongstack/core/utils/error";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils/error";
 import { makeProviderFromConfig } from "@wrongstack/providers";
 
 // src/webui-server/provider-config.ts
 import * as path from "node:path";
 import { DefaultSecretVault } from "@wrongstack/core/security";
+import { ProviderConfigSnapshots } from "@wrongstack/providers";
+var snapshots = new ProviderConfigSnapshots();
 function getVault(globalConfigPath) {
   const configDir = path.dirname(globalConfigPath ?? "");
   const parentDir = path.dirname(configDir);
@@ -248,7 +561,7 @@ function getVault(globalConfigPath) {
 }
 async function loadSavedProviders(globalConfigPath) {
   if (!globalConfigPath) return {};
-  return loadConfigProviders(globalConfigPath, getVault(globalConfigPath));
+  return snapshots.track(await loadConfigProviders(globalConfigPath, getVault(globalConfigPath)));
 }
 async function saveProviders(globalConfigPath, providers) {
   if (!globalConfigPath) return;
@@ -256,14 +569,56 @@ async function saveProviders(globalConfigPath, providers) {
     globalConfigPath,
     getVault(globalConfigPath),
     (existing) => {
+      const merged = snapshots.merge(existing, providers);
       for (const key of Object.keys(existing)) delete existing[key];
-      Object.assign(existing, providers);
+      Object.assign(existing, merged);
+      for (const key of Object.keys(providers)) delete providers[key];
+      Object.assign(providers, merged);
     }
   );
+  snapshots.track(providers);
 }
 function createProviderConfigStore(globalConfigPath, configProvidersRef) {
+  if (configProvidersRef && globalConfigPath) {
+    const views = /* @__PURE__ */ new WeakMap();
+    const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    return {
+      load: async () => {
+        const disk = await loadSavedProviders(globalConfigPath);
+        const providers = structuredClone(configProvidersRef());
+        views.set(providers, { view: structuredClone(providers), disk });
+        return providers;
+      },
+      save: async (providers) => {
+        const baseline = views.get(providers);
+        if (!baseline) {
+          throw new Error("Load the provider list before saving. Refresh and try again.");
+        }
+        const pending = structuredClone(baseline.disk);
+        snapshots.track(pending);
+        for (const id of /* @__PURE__ */ new Set([...Object.keys(baseline.view), ...Object.keys(providers)])) {
+          if (equal(baseline.view[id], providers[id])) continue;
+          if (!equal(baseline.view[id], baseline.disk[id])) {
+            throw new Error(
+              `Provider "${id}" comes from another config file. Edit its source config or create a new auth profile alias.`
+            );
+          }
+          if (Object.hasOwn(providers, id)) pending[id] = structuredClone(providers[id]);
+          else delete pending[id];
+        }
+        await saveProviders(globalConfigPath, pending);
+        for (const id of Object.keys(providers)) {
+          if (equal(baseline.view[id], baseline.disk[id])) delete providers[id];
+        }
+        for (const [id, record] of Object.entries(pending)) {
+          if (equal(baseline.view[id], baseline.disk[id])) providers[id] = record;
+        }
+        views.set(providers, { view: structuredClone(providers), disk: structuredClone(pending) });
+      }
+    };
+  }
   return {
-    load: () => configProvidersRef ? Promise.resolve(configProvidersRef()) : loadSavedProviders(globalConfigPath),
+    load: () => configProvidersRef ? Promise.resolve(snapshots.track(structuredClone(configProvidersRef()))) : loadSavedProviders(globalConfigPath),
     save: (providers) => saveProviders(globalConfigPath, providers)
   };
 }
@@ -344,7 +699,7 @@ function startWebuiCredentialWatcher({
         console.log(`[WebUI] Provider credentials reloaded from config.json (${activeId})`);
       } catch (err) {
         console.warn(
-          `[WebUI] Credential hot-reload failed for ${activeId}: ${toErrorMessage(err)}`
+          `[WebUI] Credential hot-reload failed for ${activeId}: ${toErrorMessage2(err)}`
         );
       }
     },
@@ -364,52 +719,24 @@ function startWebuiCredentialWatcher({
 
 // src/webui-server/domain-handlers.ts
 import * as os from "node:os";
-import * as path3 from "node:path";
-import { resolveWstackPaths } from "@wrongstack/core/utils";
-import {
-  buildSddWizardDeps,
-  GoalWebSocketHandler,
-  SddBoardWebSocketHandler,
-  SddWizardWebSocketHandler,
-  SpecsWebSocketHandler,
-  TerminalWebSocketHandler,
-  WorktreeWebSocketHandler
-} from "@wrongstack/webui-server";
-
-// src/webui-server/logger-shim.ts
-var structuredLine = (level, message) => JSON.stringify({
-  level,
-  event: "webui.goal",
-  message,
-  timestamp: (/* @__PURE__ */ new Date()).toISOString()
-});
-var consoleLogger = {
-  level: "debug",
-  error(msg, _ctx) {
-    console.error(structuredLine("error", msg));
-  },
-  warn(msg, _ctx) {
-    console.warn(structuredLine("warn", msg));
-  },
-  info(msg, _ctx) {
-    console.log(structuredLine("info", msg));
-  },
-  debug(msg, _ctx) {
-    console.debug(structuredLine("debug", msg));
-  },
-  trace(msg, _ctx) {
-    console.debug(structuredLine("trace", msg));
-  },
-  child(_bindings) {
-    return this;
-  }
-};
+import * as path3 from "node:path";
+import { resolveWstackPaths } from "@wrongstack/core/utils";
+import {
+  buildSddWizardDeps,
+  GoalWebSocketHandler,
+  SddBoardWebSocketHandler,
+  SddWizardWebSocketHandler,
+  SpecsWebSocketHandler,
+  TerminalWebSocketHandler,
+  WorktreeWebSocketHandler
+} from "@wrongstack/webui-server";
 
 // src/webui-server/node-pty-loader.ts
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import * as path2 from "node:path";
 import { fileURLToPath } from "node:url";
+import { isStandaloneBinary } from "@wrongstack/core/utils";
 import { repairNodePtySpawnHelper } from "@wrongstack/webui-server";
 function createNodePtyLoader(importMetaUrl, logger) {
   const requireFromCli = createRequire(importMetaUrl);
@@ -421,6 +748,10 @@ function createNodePtyLoader(importMetaUrl, logger) {
   };
   return () => {
     if (cachedNodePty !== void 0) return cachedNodePty;
+    if (isStandaloneBinary()) {
+      cachedNodePty = null;
+      return null;
+    }
     try {
       const webuiEntry = requireFromCli.resolve("@wrongstack/webui");
       const webuiDir = webuiEntry.replace(/[\\/]dist.*$/, "");
@@ -467,7 +798,7 @@ function createNodePtyLoader(importMetaUrl, logger) {
 
 // src/webui-server/domain-handlers.ts
 function createWebuiDomainHandlers(opts, trustBoundary, kanbanRunMirror) {
-  const goalStoreDir = opts.projectRoot ? path3.join(opts.projectRoot, ".wrongstack", "goal") : path3.join(os.tmpdir(), ".wrongstack", "goal");
+  const goalStoreDir = opts.projectRoot ? resolveWstackPaths({ projectRoot: opts.projectRoot }).projectAutophase : path3.join(os.tmpdir(), ".wrongstack", "goal");
   const goalHandler = new GoalWebSocketHandler(
     opts.agent,
     opts.agent.ctx,
@@ -475,7 +806,8 @@ function createWebuiDomainHandlers(opts, trustBoundary, kanbanRunMirror) {
     goalStoreDir,
     opts.events,
     opts.projectRoot,
-    kanbanRunMirror ? (graphId, state) => kanbanRunMirror.onGoalState(graphId, state) : void 0
+    kanbanRunMirror ? (graphId, state) => kanbanRunMirror.onGoalState(graphId, state) : void 0,
+    opts.sddSubagentFactory
   );
   const worktreeHandler = new WorktreeWebSocketHandler(opts.events, consoleLogger);
   const loadNodePtyViaWebui = createNodePtyLoader(import.meta.url, consoleLogger);
@@ -607,10 +939,10 @@ function createCliKanbanHostRoutes(deps) {
         });
         return;
       }
-      const snapshots = await deps.kanbanSupervisor.auditNow(boardId);
+      const snapshots2 = await deps.kanbanSupervisor.auditNow(boardId);
       send(ws, {
         type: "kanban.supervisor.audit",
-        payload: { success: true, data: boardId ? snapshots[0] ?? null : snapshots }
+        payload: { success: true, data: boardId ? snapshots2[0] ?? null : snapshots2 }
       });
     },
     runStart: async (ws, msg) => {
@@ -702,19 +1034,6 @@ function createCliKanbanHostRoutes(deps) {
   };
 }
 
-// src/webui-server/kanban-supervisor.ts
-import {
-  createKanbanSupervisor
-} from "@wrongstack/webui-server";
-
-// src/webui-server/lifecycle.ts
-import {
-  announceWebuiReady,
-  createWebuiShutdown,
-  registerWebuiInstance,
-  registerWebuiSignalHandlers
-} from "@wrongstack/webui-server";
-
 // src/webui-server/listen-helpers.ts
 import * as http from "node:http";
 import { listenWithRetry } from "@wrongstack/webui-server";
@@ -878,6 +1197,7 @@ import {
 import { TOKENS as TOKENS2 } from "@wrongstack/core/kernel";
 import { SkillInstaller } from "@wrongstack/core/skills";
 import { PromptUsageStore } from "@wrongstack/core/storage";
+import { resolveTokenSavingTier } from "@wrongstack/core/types";
 import { resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
 import {
   createChimeraRouteHandlers,
@@ -1012,6 +1332,16 @@ function createWebuiRouteContexts({
     pendingConfirms,
     configStore: opts.agent.container?.safeResolve?.(TOKENS2.ConfigStore),
     systemPrompt: {
+      previewContext: (sessionId) => {
+        const target = sessionId ? getSessionAgent(sessionId).ctx : opts.agent.ctx;
+        return {
+          toolNames: target.tools.map((tool) => tool.name),
+          tier: resolveTokenSavingTier(
+            opts.appConfig?.features?.tokenSavingMode,
+            target.provider?.capabilities?.maxContext
+          )
+        };
+      },
       paths: () => {
         const wpaths = resolveWstackPaths3({ projectRoot: promptProjectRoot(), globalRoot });
         return {
@@ -1161,6 +1491,7 @@ function createWebuiRouteContexts({
 // src/webui-server/session-start-payload.ts
 import * as path6 from "node:path";
 import { DEFAULT_CONTEXT_WINDOW_MODE_ID } from "@wrongstack/core/types";
+import { catalogProviderIdFor } from "@wrongstack/providers";
 import { protocolAdvertisement } from "@wrongstack/webui-protocol";
 
 // src/webui-server/cost-helpers.ts
@@ -1182,7 +1513,11 @@ function createSessionStartPayloadBuilder(deps) {
     const updateInfo = deps.updateInfo;
     try {
       if (deps.modelsRegistry) {
-        const m = await deps.modelsRegistry.getModel(ctx.provider.id, ctx.model);
+        const catalogId = catalogProviderIdFor(
+          ctx.provider.id,
+          deps.appConfig?.providers?.[ctx.provider.id]?.type
+        );
+        const m = await deps.modelsRegistry.getModel(catalogId, ctx.model);
         const registryMax = m?.capabilities.maxContext;
         maxContext = registryMax ?? ctx.provider.capabilities?.maxContext ?? 0;
         const rates = getCostRates(m);
@@ -1432,63 +1767,14 @@ async function runWebUI(opts) {
     get session() {
       return opts.session;
     },
+    get appConfig() {
+      return opts.appConfig;
+    },
     // `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,
-    events: opts.events,
-    hqSessionId: opts.session.id,
-    getSessionId: () => opts.agent.ctx.session?.id ?? opts.session.id,
-    // One HQ session per open tab. The set is the same one the terminal
-    // panel lists: every session a connected browser is displaying.
-    listSessions: () => {
-      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);
-      }
-      return [...ids];
-    },
-    // `cli-main` already runs a tracker and a bridge for the boot session.
-    // Announcing it here too would put two trackers on one bus flushing the
-    // same agent list.
-    isSessionOwnedElsewhere: (sessionId) => sessionId === opts.session.id,
-    // The tab's own journal, so HQ takes its turns from the write path
-    // instead of tailing the file.
-    getSessionWriter: (sessionId) => sessionAgentsRef?.peek(sessionId)?.ctx.session,
-    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.
-      // Every open tab is its own session with its own abort controller, so
-      // the command's session is the one that gets stopped. Falling back to
-      // the boot session keeps a dashboard that sends no session — every one
-      // before this existed — behaving exactly as before.
-      interruptLeader: (sessionId) => {
-        const leaderId = sessionId ?? 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 {
-        }
-        return true;
-      },
-      allowRunCommand: () => opts.hqAllowExec === true,
-      // A command naming a tab this process no longer holds is refused, not
-      // redirected onto the boot session: the operator picked a terminal,
-      // and steering a different one is worse than not steering at all.
-      ownsSession: (sessionId) => sessionId === opts.session.id || sessionAgentsRef?.has(sessionId) === true
-    }
-  });
+  const { register: registerWebuiClient, unregister: unregisterWebuiClient } = createEmbeddedClientRegistration(opts, clients, abortControllers, () => sessionAgentsRef);
   registerWebuiClient();
   const wsToken = resolveAuthToken(opts.accessToken);
   const publicHostnames = [publicUrl, publicWsUrl].map((value) => {
@@ -1690,7 +1976,7 @@ async function runWebUI(opts) {
     log: (m) => console.log(m)
   };
   const embeddedProviderOperations = createEmbeddedProviderOperations(wsHandlerCtx);
-  let credentialWatcherClose = startWebuiCredentialWatcher({
+  const credentialWatcherClose = startWebuiCredentialWatcher({
     opts,
     profileConfigPath,
     broadcast,
@@ -1728,28 +2014,13 @@ async function runWebUI(opts) {
     broadcast,
     logger: { warn: (message) => consoleLogger.warn(message) }
   }) : void 0;
-  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 stopLiveStatusLogger = startEmbeddedLiveStatusLogger(
+    opts,
+    clients,
+    abortControllers,
+    () => sessionAgentsRef,
+    terminalLogView
+  );
   const releaseSessionSalvage = addFatalSalvageHook(() => {
     try {
       sessionAgents.flushAllSync();
@@ -1779,7 +2050,15 @@ async function runWebUI(opts) {
       void sessionAgents.endAndClose(sessionId);
     }
   };
-  const stopEmptySessionCleanup = opts.sessionStore ? scheduleOwnerlessEmptySessionCleanup({
+  const refreshSessionHistory = async () => {
+    const list = await opts.sessionStore?.list(200);
+    if (!list) return;
+    broadcastEveryone({
+      type: "sessions.list",
+      payload: { sessions: toSessionHistoryEntries(list, foregroundSession.id) }
+    });
+  };
+  const emptySessionCleanup = opts.sessionStore ? scheduleOwnerlessEmptySessionCleanup({
     getSessionStore: () => opts.sessionStore,
     getActiveSessionId: () => foregroundSession.id,
     getActiveSessionIds: () => collectDisplayedSessionIds({ getSession: () => foregroundSession, clients }),
@@ -1787,16 +2066,19 @@ async function runWebUI(opts) {
     // 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) }
-      });
-    },
+    refreshSessions: refreshSessionHistory,
     logger: consoleLogger
   }) : null;
+  const offSessionRenamed = opts.sessionStore ? opts.events.on("session.renamed", () => {
+    void refreshSessionHistory().catch(() => void 0);
+  }) : void 0;
+  const stopEmptySessionCleanup = emptySessionCleanup && {
+    runNow: emptySessionCleanup.runNow,
+    dispose: async () => {
+      offSessionRenamed?.();
+      await emptySessionCleanup.dispose();
+    }
+  };
   const routeContexts = createWebuiRouteContexts({
     opts,
     profileConfigPath,
@@ -1837,6 +2119,7 @@ async function runWebUI(opts) {
   const shutdown = () => signalShutdown?.();
   let embeddedAutoHealDispose = null;
   const handleMessage = createEmbeddedMessageRouter({
+    jevVault: getVault(opts.globalConfigPath ?? opts.profileConfigPath),
     trustBoundary,
     opts,
     logger: consoleLogger,
@@ -1872,148 +2155,72 @@ async function runWebUI(opts) {
     kanbanHostRoutes,
     statusTracker: opts.statusTracker
   });
-  const stopped = new Promise((resolve) => {
-    let listeningAnnounced = false;
-    const announceListening = () => {
-      if (listeningAnnounced) return;
-      listeningAnnounced = true;
-      console.log(`[WebUI] WebSocket server running on ws://${host}:${httpPort}`);
-      try {
-        setupEvents();
-        opts.onListening?.({
-          httpPort,
-          wsPort,
-          host,
-          url: accessUrl,
-          authToken: wsToken,
-          webuiInstanceRegistered
-        });
-      } catch (err) {
-        consoleLogger.error("setup_events_failed", { message: toErrorMessage2(err) });
-      }
-    };
-    wss.on("listening", announceListening);
-    if (httpServer?.server.listening || wss.address()) queueMicrotask(announceListening);
-    wss.on(
-      "connection",
-      createConnectionHandler({
-        host,
-        wsToken,
-        requireToken,
-        publicHostnames,
-        publicWsUrl,
-        clients,
-        currentSessionId,
-        goalHandler,
-        specsHandler,
-        sddBoardHandler,
-        sddWizardHandler,
-        worktreeHandler,
-        terminalHandler,
-        rateLimitMax,
-        send,
-        sessionPayload,
-        handleMessage,
-        pendingConfirms,
-        buildSessionStartPayload,
-        loadReplay: async () => {
-          const activeSession = opts.agent.ctx.session ?? opts.session;
-          await activeSession.flush();
-          if (opts.sessionStore) {
-            const data = await opts.sessionStore.load(activeSession.id);
-            return { messages: data.messages, events: data.events, usage: data.usage };
-          }
-          const usage = opts.agent.ctx.tokenCounter.total();
-          return { messages: opts.agent.ctx.messages, usage };
-        },
-        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
-      })
-    );
-    signalShutdown = createWebuiShutdown({
-      abortInFlight: () => {
-        void embeddedAutoHealDispose?.();
-        for (const c of abortControllers.values()) c.abort();
-        abortControllers.clear();
-      },
-      unsubscribeEvents: () => {
-        flushAllStreamBuffers();
-        for (const unsub of eventUnsubscribers) unsub();
-      },
-      stopOwnedChildren: async () => {
-        try {
-          const { getProcessRegistry } = await import("@wrongstack/tools");
-          getProcessRegistry().killAll({ force: true, includeProtected: true });
-        } catch (err) {
-          console.debug(
-            `[webui-server] process-registry killAll failed: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
-        if (opts.mcpRegistry) {
-          try {
-            await opts.mcpRegistry.stopAll();
-          } catch (err) {
-            console.debug(
-              `[webui-server] mcpRegistry.stopAll failed: ${err instanceof Error ? err.message : String(err)}`
-            );
-          }
-        }
-      },
-      disposeResources: async () => {
-        releaseSessionSalvage();
-        autoWakeHost?.dispose();
-        await stopEmptySessionCleanup?.dispose();
-        await sessionAgents.closeAll().catch(() => void 0);
-        credentialWatcherClose?.();
-        credentialWatcherClose = void 0;
-        goalHandler.dispose();
-        sddBoardHandler.dispose();
-        worktreeHandler.dispose();
-        terminalHandler.dispose();
-        kanbanRunMirror?.dispose();
-        kanbanSupervisor?.dispose();
-        void stopKanbanSupervisorMemoryStats?.();
-        await embeddedAutoHealDispose?.();
-        embeddedAutoHealDispose = null;
-        unregisterWebuiClient();
+  const { stopped } = runWebuiServerLifecycle({
+    host,
+    httpPort,
+    setupEvents,
+    opts,
+    wsPort,
+    accessUrl,
+    wsToken,
+    webuiInstanceRegistered,
+    wss,
+    httpServer,
+    requireToken,
+    publicHostnames,
+    publicWsUrl,
+    clients,
+    currentSessionId,
+    goalHandler,
+    specsHandler,
+    sddBoardHandler,
+    sddWizardHandler,
+    worktreeHandler,
+    terminalHandler,
+    rateLimitMax,
+    send,
+    sessionPayload,
+    handleMessage,
+    pendingConfirms,
+    buildSessionStartPayload,
+    sessionAgents,
+    lifecycleState: {
+      get signalShutdown() {
+        return signalShutdown;
       },
-      closeClients: () => {
-        for (const [ws] of clients) ws.close();
-        clients.clear();
+      set signalShutdown(value) {
+        signalShutdown = value;
       },
-      closeHttpServer: () => {
-        ipv6LoopbackServer?.close();
-        httpServer?.server.close();
+      get embeddedAutoHealDispose() {
+        return embeddedAutoHealDispose;
       },
-      wss,
-      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_LOGS=1 to stream them.`
-          );
-        }
-        opts.onExit?.();
-        resolve();
+      set embeddedAutoHealDispose(value) {
+        embeddedAutoHealDispose = value;
       }
-    });
-    registerWebuiSignalHandlers(signalShutdown);
+    },
+    abortControllers,
+    flushAllStreamBuffers,
+    eventUnsubscribers,
+    releaseSessionSalvage,
+    autoWakeHost,
+    stopEmptySessionCleanup,
+    credentialWatcherClose,
+    kanbanRunMirror,
+    kanbanSupervisor,
+    stopKanbanSupervisorMemoryStats,
+    unregisterWebuiClient,
+    ipv6LoopbackServer,
+    registryBaseDir,
+    stopLiveStatusLogger,
+    terminalLogView
   });
   function send(ws, msg) {
     sendSerialized(ws, JSON.stringify(stampDispatchSession(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);
+    const data = sessionId ? webuiSessionFrameLog().sequence(sessionId, msg) : JSON.stringify(msg);
     for (const [ws, client] of clients) {
       if (clientWantsSession(client, sessionId)) sendSerialized(ws, data);
     }
@@ -2030,4 +2237,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-MRPGTTKL.js.map
+//# sourceMappingURL=webui-server-YTHLRFD2.js.map