@wrongstack/cli 0.284.1 → 0.286.0

package/dist/webui-server/lifecycle.d.ts

@@ -0,0 +1,108 @@
+import { type WebUIInstanceRecord } from '@wrongstack/webui/server';
+/**
+ * PR 7 of Issue #30 (webui-server 8-PR refactor): process lifecycle.
+ *
+ * Three concerns pulled out of the ~3000-line `runWebUI` body:
+ *
+ *   - `registerWebuiInstance` — record this embedded WebUI in the shared
+ *     running-instance registry (so `wstackui --list` sees it).
+ *   - `announceWebuiReady` — log the ready banner and pop the browser
+ *     once the HTTP server is listening.
+ *   - `createWebuiShutdown` + `registerWebuiSignalHandlers` — the
+ *     SIGINT/SIGTERM teardown sequence.
+ *
+ * Each external dependency (registry IO, browser launch) is an
+ * injectable seam so the orchestration can be unit-tested without
+ * touching disk or spawning a browser. Run-loop state (abort
+ * controllers, client map, the run promise's `resolve`) stays in
+ * `webui-server.ts` and is threaded in as callbacks — the module never
+ * captures it.
+ */
+export interface RegisterWebuiInstanceParams {
+    pid: number;
+    host: string;
+    httpPort: number;
+    wsPort: number;
+    /** Browser-facing public URL when served through a tunnel/proxy. */
+    publicUrl?: string | undefined;
+    projectRoot: string;
+    /** ISO timestamp when the instance registered. */
+    startedAt: string;
+    /** Registry base dir (dirname of globalConfigPath); undefined ⇒ registry default. */
+    registryBaseDir: string | undefined;
+}
+export interface RegisterWebuiInstanceDeps {
+    registerFn?: (record: WebUIInstanceRecord, baseDir?: string) => Promise<void>;
+}
+/**
+ * Fire-and-forget registration of this WebUI in the running-instance
+ * registry. Best-effort: a registry write error never blocks startup and
+ * is swallowed (the registry is a convenience index, not a source of
+ * truth). Caller guards on `projectRoot` being known.
+ */
+export declare function registerWebuiInstance(p: RegisterWebuiInstanceParams, deps?: RegisterWebuiInstanceDeps): void;
+export interface AnnounceWebuiReadyParams {
+    /** The HTTP server (StaticServeHandle.server). */
+    server: {
+        on: (event: 'listening', cb: () => void) => void;
+    };
+    host: string;
+    httpPort: number;
+    wsPort: number;
+    open: boolean;
+    /** Auth token for WS connections. Included in the URL so the frontend can exchange it for an HttpOnly cookie via /ws-auth. */
+    wsToken?: string;
+    /** Browser-facing public URL when served through a tunnel/proxy. */
+    publicUrl?: string | undefined;
+    log?: (msg: string) => void;
+    openBrowserFn?: (url: string) => void;
+}
+/**
+ * Once the HTTP server is listening, print the ready banner and (if
+ * `open`) launch the browser at the served URL.
+ */
+export declare function announceWebuiReady(p: AnnounceWebuiReadyParams): void;
+export interface WebuiShutdownResources {
+    /** Abort every in-flight run (legacy single slot + per-socket controllers) and clear them. */
+    abortInFlight: () => void;
+    /** Run and drop every event-bus unsubscriber. */
+    unsubscribeEvents: () => void;
+    /** Close every connected socket and clear the client map. */
+    closeClients: () => void;
+    /** Close the static HTTP server (no-op when WS-only). */
+    closeHttpServer: () => void;
+    /** The WebSocket server to stop (its close callback resolves the run promise). */
+    wss: {
+        close: (cb?: () => void) => void;
+    };
+    /** This process's pid — the registry liveness key. */
+    pid: number;
+    /** Registry base dir (undefined ⇒ registry default). */
+    registryBaseDir: string | undefined;
+    /** Called once teardown settles — wired to the run promise's `resolve`. */
+    onStopped: () => void;
+    log?: (msg: string) => void;
+    debug?: (msg: string) => void;
+    /** Injectable for tests; defaults to the real registry unregister. */
+    unregisterFn?: (pid: number, baseDir?: string) => Promise<void>;
+}
+/**
+ * Build the SIGINT/SIGTERM teardown handler. The returned function is
+ * idempotent: the first call runs the teardown, later calls (e.g. a
+ * second Ctrl+C, or a signal after another server in the same process
+ * already stopped) return immediately.
+ *
+ * Order matches the original inline handler: abort runs → unsubscribe
+ * events → close clients → unregister from the instance registry (async,
+ * awaited inside the wss.close callback) → close HTTP → close WS → on
+ * close, once the unregister settles, `onStopped()`.
+ */
+export declare function createWebuiShutdown(res: WebuiShutdownResources): () => void;
+/**
+ * Register `shutdown` on SIGINT and SIGTERM. The wrapper self-detaches
+ * both listeners on first fire (so a server that has already shut down
+ * can't re-trigger teardown). Returns an unregister function for tests
+ * and clean restarts.
+ */
+export declare function registerWebuiSignalHandlers(shutdown: () => void): () => void;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/webui-server/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../src/webui-server/lifecycle.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;;;;;;;;;GAkBG;AAIH,MAAM,WAAW,2BAA2B;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,2BAA2B,EAC9B,IAAI,GAAE,yBAA8B,GACnC,IAAI,CAmBN;AAID,MAAM,WAAW,wBAAwB;IACvC,kDAAkD;IAClD,MAAM,EAAE;QAAE,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;KAAE,CAAC;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,8HAA8H;IAC9H,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAmBpE;AAID,MAAM,WAAW,sBAAsB;IACrC,8FAA8F;IAC9F,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,6DAA6D;IAC7D,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,yDAAyD;IACzD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,kFAAkF;IAClF,GAAG,EAAE;QAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;KAAE,CAAC;IAC1C,sDAAsD;IACtD,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,sEAAsE;IACtE,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,sBAAsB,GAAG,MAAM,IAAI,CA2B3E;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAY5E"}

package/dist/webui-server/logger-shim.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from '@wrongstack/core';
+/**
+ * Console-backed `Logger` adapter for the CLI. Routes each
+ * level to the matching `console.*` method and wraps the
+ * message in a structured JSON line. The `child()` method
+ * returns the same logger — the CLI shim does not maintain
+ * a binding chain.
+ */
+export declare const consoleLogger: Logger;
+//# sourceMappingURL=logger-shim.d.ts.map

package/dist/webui-server/logger-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-shim.d.ts","sourceRoot":"","sources":["../../src/webui-server/logger-shim.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAiB/C;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,MAoB3B,CAAC"}

package/dist/webui-server/message-router.d.ts

@@ -0,0 +1,39 @@
+import type { AutoPhaseWebSocketHandler, DesignContext, PromptsContext, SddBoardWebSocketHandler, SddWizardWebSocketHandler, SkillsContext, SpecsWebSocketHandler, TerminalWebSocketHandler, WorktreeWebSocketHandler } from '@wrongstack/webui/server';
+import type { WebSocket } from 'ws';
+import type { CliWebUIOptions, WSClientMessage, WSServerMessage } from '../webui-server.js';
+import type { ConnectedClient } from './connection-handler.js';
+import type { AgentConfigContext, BrainHandlerContext, ConnectionContext, ContextHandlerContext, IntrospectionContext, MailboxContext, PrefsContext, ProjectsContext, SessionsContext, WorklistContext, WsCommon, WsHandlerContext } from './ws-handlers/index.js';
+export interface MessageRouterDeps {
+    opts: CliWebUIOptions;
+    send: (ws: WebSocket, msg: WSServerMessage) => void;
+    sendResult: (ws: WebSocket, success: boolean, message: string) => void;
+    sessionPayload: <T extends Record<string, unknown>>(payload: T) => T & {
+        sessionId: string;
+    };
+    currentSessionId: () => string;
+    shutdown: () => void;
+    wsHandlerCtx: WsHandlerContext;
+    brainCtx: BrainHandlerContext;
+    introspectionCtx: IntrospectionContext;
+    skillsCtx: SkillsContext;
+    promptsCtx: PromptsContext;
+    designCtx: DesignContext;
+    worklistCtx: WorklistContext;
+    agentConfigCtx: AgentConfigContext;
+    prefsCtx: PrefsContext;
+    projectsCtx: ProjectsContext;
+    contextHandlerCtx: ContextHandlerContext;
+    wsCommon: WsCommon;
+    mailboxCtx: MailboxContext;
+    sessionsCtx: SessionsContext;
+    connectionCtx: ConnectionContext;
+    autoPhaseHandler: AutoPhaseWebSocketHandler;
+    specsHandler: SpecsWebSocketHandler;
+    sddBoardHandler: SddBoardWebSocketHandler;
+    sddWizardHandler: SddWizardWebSocketHandler | null;
+    worktreeHandler: WorktreeWebSocketHandler;
+    terminalHandler: TerminalWebSocketHandler;
+}
+export type MessageRouter = (ws: WebSocket, client: ConnectedClient, msg: WSClientMessage) => Promise<void>;
+export declare function createMessageRouter(deps: MessageRouterDeps): MessageRouter;
+//# sourceMappingURL=message-router.d.ts.map

package/dist/webui-server/message-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-router.d.ts","sourceRoot":"","sources":["../../src/webui-server/message-router.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,0BAA0B,CAAC;AAkDlC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC5F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,eAAe,EACf,eAAe,EACf,QAAQ,EACR,gBAAgB,EACjB,MAAM,wBAAwB,CAAC;AAkFhC,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,KAAK,IAAI,CAAC;IACpD,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACvE,cAAc,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7F,gBAAgB,EAAE,MAAM,MAAM,CAAC;IAC/B,QAAQ,EAAE,MAAM,IAAI,CAAC;IAErB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,cAAc,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,WAAW,EAAE,eAAe,CAAC;IAC7B,cAAc,EAAE,kBAAkB,CAAC;IACnC,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,EAAE,eAAe,CAAC;IAC7B,iBAAiB,EAAE,qBAAqB,CAAC;IACzC,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,cAAc,CAAC;IAC3B,WAAW,EAAE,eAAe,CAAC;IAC7B,aAAa,EAAE,iBAAiB,CAAC;IAEjC,gBAAgB,EAAE,yBAAyB,CAAC;IAC5C,YAAY,EAAE,qBAAqB,CAAC;IACpC,eAAe,EAAE,wBAAwB,CAAC;IAC1C,gBAAgB,EAAE,yBAAyB,GAAG,IAAI,CAAC;IACnD,eAAe,EAAE,wBAAwB,CAAC;IAC1C,eAAe,EAAE,wBAAwB,CAAC;CAC3C;AAED,MAAM,MAAM,aAAa,GAAG,CAC1B,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,eAAe,EACvB,GAAG,EAAE,eAAe,KACjB,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,aAAa,CAunB1E"}

package/dist/webui-server/prefs-seeding.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Preference key list, snapshot, persistence, and config-seeding.
+ *
+ * ## What lives here
+ *
+ * - `PREF_KEYS`           – the canonical list of browser-setting ↔ config-file keys.
+ * - `createPrefsSeeding`  – factory that returns `{ prefSnapshot, persistPrefs }`
+ *                           with file I/O captured in closure.
+ * - `seedConfigToMeta`    – one-time call at startup: reads config.json and seeds
+ *                           `agent.ctx.meta` so the settings panel shows the real
+ *                           persisted values instead of localStorage defaults.
+ *
+ * ## Extraction history
+ *
+ * PR 9 of Issue #30 – extracted from webui-server.ts (was inline between the
+ * `PREF_KEYS` array and the `PrefsContext` construction).
+ */
+import type { Config } from '@wrongstack/core';
+interface CliWebUIOptions {
+    agent: {
+        ctx: {
+            meta: Record<string, unknown>;
+        };
+    };
+    globalConfigPath?: string | undefined;
+    appConfig?: {
+        fallbackModels?: string[] | undefined;
+        fallbackProfiles?: Record<string, string[]> | undefined;
+        favoriteModels?: string[] | undefined;
+        favoriteModelsOnly?: boolean | undefined;
+        fallbackAuto?: boolean | undefined;
+        modelMatrix?: Config['modelMatrix'] | undefined;
+        uiLocale?: string | undefined;
+    } | undefined;
+}
+/** Keys synced between `agent.ctx.meta` and `config.json`. */
+export declare const PREF_KEYS: readonly ['autonomy', 'autonomyDelayMs', 'autoProceedMaxIterations', 'yolo', 'maxIterations', 'chime', 'confirmExit', 'streamFleet', 'nextPrediction', 'fallbackModels', 'fallbackProfiles', 'favoriteModels', 'favoriteModelsOnly', 'modelMatrix', 'fallbackAuto', 'uiLocale', 'enhanceEnabled', 'enhanceDelayMs', 'enhanceLanguage', 'featureMcp', 'featurePlugins', 'featureMemory', 'featureSkills', 'featureModelsRegistry', 'indexOnStart', 'contextAutoCompact', 'contextStrategy', 'contextMode', 'tokenSavingTier', 'maxConcurrent', 'titleAnimation', 'reasoningMode', 'reasoningEffort', 'reasoningPreserve', 'cacheTtl', 'logLevel', 'auditLevel', 'hqEnabled', 'hqUrl', 'hqToken', 'hqRawContent', 'refinerProvider', 'refinerModel', 'thinkingWord', 'statuslineMode', 'animationStyle', 'tgConfigured', 'tgSessionEnd', 'tgDelegate', 'tgLongToolMs', 'breakerEnabled', 'breakerAutoKillResetMs', 'fsAccess', 'debugStream'];
+type PrefSnapshot = Record<string, unknown>;
+/**
+ * One-time startup seed: reads `globalConfigPath` and copies recognised fields
+ * into `agent.ctx.meta` so the browser settings panel starts with the real
+ * persisted values instead of blank/undefined.
+ *
+ * Best-effort – missing or corrupt config leaves prefs unseeded.
+ */
+export declare function seedConfigToMeta(opts: CliWebUIOptions): Promise<void>;
+interface PrefsSeeding {
+    prefSnapshot: () => PrefSnapshot;
+    persistPrefs: (payload: PrefSnapshot) => Promise<void>;
+}
+/**
+ * Factory – returns `prefSnapshot` and `persistPrefs` with file I/O captured
+ * in closure. Call once per `runWebUI` instance.
+ */
+export declare function createPrefsSeeding(opts: CliWebUIOptions): PrefsSeeding;
+export {};
+//# sourceMappingURL=prefs-seeding.d.ts.map

package/dist/webui-server/prefs-seeding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefs-seeding.d.ts","sourceRoot":"","sources":["../../src/webui-server/prefs-seeding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK/C,UAAU,eAAe;IACvB,KAAK,EAAE;QAAE,GAAG,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAA;KAAE,CAAC;IAClD,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,SAAS,CAAC,EAAE;QACV,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;QACtC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,SAAS,CAAC;QACxD,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;QACtC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QACzC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QACnC,WAAW,CAAC,EAAE,MAAM,CAAC,aAAa,CAAC,GAAG,SAAS,CAAC;QAChD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KAC/B,GAAG,SAAS,CAAC;CACf;AAWD,8DAA8D;AAC9D,eAAO,MAAM,SAAS,YACpB,UAAU,EACV,iBAAiB,EACjB,0BAA0B,EAC1B,MAAM,EACN,eAAe,EACf,OAAO,EACP,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,EACb,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,uBAAuB,EACvB,cAAc,EACd,oBAAoB,EACpB,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAIhB,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,WAAW,EACX,OAAO,EACP,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAEhB,cAAc,EACd,cAAc,EACd,YAAY,EACZ,cAAc,EAEd,gBAAgB,EAChB,wBAAwB,EACxB,UAAU,EACV,aAAa,CACL,CAAC;AAIX,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAI5C;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAsG3E;AAID,UAAU,YAAY;IACpB,YAAY,EAAE,MAAM,YAAY,CAAC;IACjC,YAAY,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,CA2RtE"}

package/dist/webui-server/provider-config.d.ts

@@ -0,0 +1,61 @@
+import { DefaultSecretVault } from '@wrongstack/core/security';
+import type { ProviderConfig } from '@wrongstack/core/types';
+export { expectDefined, maskedKey, normalizeKeys, nowIso, writeKeysBack, } from '../provider-config-utils.js';
+/**
+ * PR 4 of Issue #30 (webui-server 8-PR refactor):
+ * provider-config IO.
+ *
+ * Before this PR, the two helpers below were inlined
+ * at the bottom of `webui-server.ts` as closure-captured
+ * helpers that read `opts.globalConfigPath` from the
+ * surrounding `runWebUI` scope. The helpers themselves
+ * are pure: given a config path and a vault, they
+ * load or save the providers map. The `globalConfigPath`
+ * closure capture is what made them untestable in
+ * isolation.
+ *
+ * After this PR, the helpers live in their own module
+ * with explicit parameters. `runWebUI` is the only
+ * caller; it now constructs the helpers at the call
+ * site or threads `globalConfigPath` through a thin
+ * adapter.
+ *
+ * Note: `writeKeysBack` and `normalizeKeys` (used by
+ * the per-handler key ops) are *already* imported from
+ * `@wrongstack/webui/server`. This PR does not move
+ * them — they were never inlined in `webui-server.ts`.
+ * Per the plan body's update after PR #51, they are
+ * not part of this extraction.
+ */
+export declare function getVault(globalConfigPath: string | undefined): DefaultSecretVault;
+export declare function loadSavedProviders(globalConfigPath: string | undefined): Promise<Record<string, ProviderConfig>>;
+export declare function saveProviders(globalConfigPath: string | undefined, providers: Record<string, ProviderConfig>): Promise<void>;
+/**
+ * A provider-config store bound to one `globalConfigPath`.
+ *
+ * PR 4 follow-up of Issue #30: the provider ws-handlers used to take a
+ * raw `globalConfigPath` and call `loadSavedProviders`/`saveProviders`
+ * with it on every operation. Binding the path once into a small
+ * `load`/`save` object (mirrors the standalone server's
+ * `createProviderConfigIO`) removes the repeated path threading and
+ * gives callers a single dependency to mock.
+ */
+export interface ProviderConfigStore {
+    load(): Promise<Record<string, ProviderConfig>>;
+    save(providers: Record<string, ProviderConfig>): Promise<void>;
+}
+/**
+ * Build a {@link ProviderConfigStore} for `globalConfigPath`. When the
+ * path is undefined the store is a no-op (load ⇒ `{}`, save ⇒ nothing),
+ * matching the underlying helpers' behaviour.
+ *
+ * @param configProvidersRef Optional callback that returns the in-memory
+ *   merged `config.providers` map (from the boot config loader which merges
+ *   global + project-local configs). When provided, `load()` returns from
+ *   this ref instead of re-reading the single global config file on disk.
+ *   This prevents a mismatch where providers stored in the project-local
+ *   config (`config.local.json`) are visible to the agent but invisible
+ *   to the WebUI's saved-providers panel.
+ */
+export declare function createProviderConfigStore(globalConfigPath: string | undefined, configProvidersRef?: () => Record<string, ProviderConfig>): ProviderConfigStore;
+//# sourceMappingURL=provider-config.d.ts.map

package/dist/webui-server/provider-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config.d.ts","sourceRoot":"","sources":["../../src/webui-server/provider-config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAU7D,OAAO,EACL,aAAa,EACb,SAAS,EACT,aAAa,EACb,MAAM,EACN,aAAa,GACd,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,wBAAgB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,kBAAkB,CAGjF;AAED,wBAAsB,kBAAkB,CACtC,gBAAgB,EAAE,MAAM,GAAG,SAAS,GACnC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAGzC;AAED,wBAAsB,aAAa,CACjC,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAWf;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;IAChD,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,gBAAgB,EAAE,MAAM,GAAG,SAAS,EACpC,kBAAkB,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,GACxD,mBAAmB,CAQrB"}

package/dist/webui-server/session-start-payload.d.ts

@@ -0,0 +1,20 @@
+import type { Context, ModelsRegistry } from '@wrongstack/core';
+/** The slice of `CliWebUIOptions` the payload builder actually reads. */
+export interface SessionStartPayloadDeps {
+    agent: {
+        ctx: Context;
+    };
+    session: {
+        id: string;
+    };
+    modelsRegistry?: ModelsRegistry | undefined;
+    modeId?: string | undefined;
+    projectRoot?: string | undefined;
+}
+export type BuildSessionStartPayload = (overrides?: Record<string, unknown>, needsSetup?: boolean) => Promise<Record<string, unknown>>;
+/**
+ * Callers pass optional overrides for fields that vary per context
+ * (reset, mode, replayMessages, etc.).
+ */
+export declare function createSessionStartPayloadBuilder(deps: SessionStartPayloadDeps): BuildSessionStartPayload;
+//# sourceMappingURL=session-start-payload.d.ts.map

package/dist/webui-server/session-start-payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-start-payload.d.ts","sourceRoot":"","sources":["../../src/webui-server/session-start-payload.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGhE,yEAAyE;AACzE,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE;QAAE,GAAG,EAAE,OAAO,CAAA;KAAE,CAAC;IACxB,OAAO,EAAE;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACxB,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,UAAU,CAAC,EAAE,OAAO,KACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAEtC;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,uBAAuB,GAC5B,wBAAwB,CAoD1B"}

package/dist/webui-server/session-status-poll.d.ts

@@ -0,0 +1,14 @@
+export interface SessionStatusPollDeps {
+    /** Directory holding session-registry.json (the wstack global root). */
+    globalRoot: string;
+    broadcast: (msg: {
+        type: string;
+        payload: unknown;
+    }) => void;
+    /** Shared disposer list — poll interval + fs watcher land here. */
+    eventUnsubscribers: Array<() => void>;
+    /** Receives the broadcaster so `/api/fleet/ping` can push-on-write. */
+    onBroadcastReady: (fn: () => Promise<void>) => void;
+}
+export declare function startSessionStatusPoll(deps: SessionStatusPollDeps): void;
+//# sourceMappingURL=session-status-poll.d.ts.map

package/dist/webui-server/session-status-poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-status-poll.d.ts","sourceRoot":"","sources":["../../src/webui-server/session-status-poll.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,qBAAqB;IACpC,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7D,mEAAmE;IACnE,kBAAkB,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;IACtC,uEAAuE;IACvE,gBAAgB,EAAE,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;CACrD;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CA4ExE"}

package/dist/webui-server/setup-events.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Event arming for the CLI WebUI bridge — every EventBus subscription that
+ * fans agent/fleet/tool/mailbox/brain activity out to connected browsers.
+ *
+ * `createSetupEvents(deps)` returns the `setupEvents()` function the server
+ * calls on `listening` (and again after a project switch): it clears the
+ * shared `eventUnsubscribers` list and re-arms every subscription, pushing
+ * each disposer back onto that list so teardown/re-arm stays centralized in
+ * the caller. Fleet-concurrency gauge state lives here too — it is only ever
+ * read and mutated by these subscriptions.
+ *
+ * PR 12 of Issue #30: extracted from `webui-server.ts`.
+ */
+import type { Context, EventBus, JournalEntry, SecretScrubber } from '@wrongstack/core';
+import { createEternalSubscription } from '@wrongstack/webui/server';
+import type { StreamCoalescer } from './stream-coalescer.js';
+import type { PendingConfirm } from './ws-handlers/index.js';
+export interface SetupEventsDeps {
+    events: EventBus;
+    agent: {
+        ctx: Context;
+    };
+    subscribeEternalIteration?: ((fn: (entry: JournalEntry) => void) => () => void) | undefined;
+    broadcast: (msg: {
+        type: string;
+        payload: unknown;
+    }) => void;
+    sessionPayload: <T extends Record<string, unknown>>(payload: T) => T & {
+        sessionId: string;
+    };
+    currentSessionId: () => string;
+    queueTextDelta: StreamCoalescer['queueTextDelta'];
+    queueThinkingDelta: StreamCoalescer['queueThinkingDelta'];
+    queueToolProgress: StreamCoalescer['queueToolProgress'];
+    flushThinkingDelta: StreamCoalescer['flushThinkingDelta'];
+    flushAllStreamBuffers: StreamCoalescer['flushAllStreamBuffers'];
+    pendingConfirms: Map<string, PendingConfirm>;
+    secretScrubber: SecretScrubber;
+    /** Live clients getter for the shared eternal-iteration subscription. */
+    getClients: Parameters<typeof createEternalSubscription>[2];
+    /** Shared disposer list — the caller also pushes non-event disposers here. */
+    eventUnsubscribers: Array<() => void>;
+}
+export declare function createSetupEvents(deps: SetupEventsDeps): () => void;
+//# sourceMappingURL=setup-events.d.ts.map

package/dist/webui-server/setup-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-events.d.ts","sourceRoot":"","sources":["../../src/webui-server/setup-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACxF,OAAO,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,QAAQ,CAAC;IACjB,KAAK,EAAE;QAAE,GAAG,EAAE,OAAO,CAAA;KAAE,CAAC;IACxB,yBAAyB,CAAC,EACtB,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC,GACnD,SAAS,CAAC;IACd,SAAS,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7D,cAAc,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7F,gBAAgB,EAAE,MAAM,MAAM,CAAC;IAC/B,cAAc,EAAE,eAAe,CAAC,gBAAgB,CAAC,CAAC;IAClD,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,CAAC;IAC1D,iBAAiB,EAAE,eAAe,CAAC,mBAAmB,CAAC,CAAC;IACxD,kBAAkB,EAAE,eAAe,CAAC,oBAAoB,CAAC,CAAC;IAC1D,qBAAqB,EAAE,eAAe,CAAC,uBAAuB,CAAC,CAAC;IAChE,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAC7C,cAAc,EAAE,cAAc,CAAC;IAC/B,yEAAyE;IACzE,UAAU,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;IAC5D,8EAA8E;IAC9E,kBAAkB,EAAE,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;CACvC;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,IAAI,CA2rBnE"}

package/dist/webui-server/static-serve.d.ts

@@ -0,0 +1,70 @@
+import type { Server } from 'node:http';
+import { type CreateHttpServerOptions } from '@wrongstack/webui/server';
+/**
+ * PR 6 of Issue #30 (webui-server 8-PR refactor):
+ * dist discovery + HTTP server bring-up.
+ *
+ * Before this PR, the `runWebUI` body inlined five lines
+ * that resolved the webui package's `dist` directory via
+ * `createRequire(import.meta.url)` and handed the path to
+ * `createHttpServer`. If the webui package wasn't built,
+ * the inline try/catch silently degraded to WS-only.
+ *
+ * After this PR, the dist-resolution lives in
+ * `webui-server/static-serve.ts` and the only thing
+ * `runWebUI` does is call `startStaticServe({ host,
+ * httpPort, wsPort, globalRoot })`. The function returns
+ * the listening `Server` and its real `port` (the OS
+ * may reassign if the requested port was in use), or
+ * `null` when the webui package is unbuilt.
+ *
+ * The try/catch around the require resolution stays
+ * inside this module so the runWebUI body does not have
+ * to think about webui's build state at all.
+ */
+export interface StaticServeHandle {
+    server: Server;
+    port: number;
+}
+export interface StaticServeOptions {
+    host: string;
+    httpPort: number;
+    wsPort: number;
+    globalRoot: string;
+    /** Push-on-write hook for `POST /api/fleet/ping` (immediate fleet re-broadcast). */
+    onFleetPing?: (() => void) | undefined;
+    /** Public browser-facing WS URL injected into the React app. */
+    publicWsUrl?: string | undefined;
+    /**
+     * Shared auth token for `/ws-auth` and `/api/*` endpoints. Required for
+     * the cookie-based auth flow: the frontend extracts this from the URL,
+     * calls `/ws-auth?token=...` to get an HttpOnly cookie, then uses the
+     * cookie for subsequent WS upgrades (closing C-598 query-string exposure).
+     */
+    apiToken?: string | undefined;
+    /** Force token auth even when the server binds to loopback. */
+    requireToken?: boolean | undefined;
+}
+/**
+ * Resolve the webui package's built `dist` directory.
+ *
+ * Returns the absolute path, or `null` if the package's
+ * server entry can't be resolved (webui not built). This
+ * is the one piece of `startStaticServe` that touches the
+ * module tree, so it lives behind its own function: tests
+ * can exercise the resolution (and stub it) without
+ * binding a socket.
+ */
+export declare function resolveDistDir(): string | null;
+/**
+ * Injectable seams for `startStaticServe`. Both default to
+ * the real implementations; tests override them to assert
+ * the wiring without resolving the webui package or binding
+ * a real port.
+ */
+export interface StaticServeDeps {
+    resolveDist?: () => string | null;
+    createServer?: (opts: CreateHttpServerOptions) => Server;
+}
+export declare function startStaticServe(opts: StaticServeOptions, deps?: StaticServeDeps): StaticServeHandle | null;
+//# sourceMappingURL=static-serve.d.ts.map

package/dist/webui-server/static-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-serve.d.ts","sourceRoot":"","sources":["../../src/webui-server/static-serve.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,KAAK,uBAAuB,EAAoB,MAAM,0BAA0B,CAAC;AAE1F;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,oFAAoF;IACpF,WAAW,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACvC,gEAAgE;IAChE,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,+DAA+D;IAC/D,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAQ9C;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;IAClC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,uBAAuB,KAAK,MAAM,CAAC;CAC1D;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,kBAAkB,EACxB,IAAI,GAAE,eAAoB,GACzB,iBAAiB,GAAG,IAAI,CA6B1B"}

package/dist/webui-server/stream-coalescer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Server-side stream coalescing for the CLI WebUI bridge.
+ *
+ * Coalesces high-volume live events (provider text/thinking deltas, tool
+ * progress) before they hit every connected browser tab. The frontend also
+ * coalesces per animation frame, but without this layer long streams still
+ * create one WebSocket message per provider token/tool progress event.
+ *
+ * PR 9 of Issue #30: extracted from `webui-server.ts`.
+ */
+export interface StreamCoalescerDeps {
+    /** Send a message to every connected client (webui-server's `broadcast`). */
+    broadcast: (msg: {
+        type: string;
+        payload: unknown;
+    }) => void;
+    /** Stamp a payload with the live session id (webui-server's `sessionPayload`). */
+    sessionPayload: <T extends Record<string, unknown>>(payload: T) => T & {
+        sessionId: string;
+    };
+}
+export interface ToolProgressPayload {
+    sessionId?: string | undefined;
+    id: string;
+    name: string;
+    event: {
+        type?: string | undefined;
+        text?: string | undefined;
+    };
+}
+export interface StreamCoalescer {
+    queueTextDelta(text: string, sessionId?: string | undefined): void;
+    queueThinkingDelta(text: string, sessionId?: string | undefined): void;
+    queueToolProgress(payload: ToolProgressPayload): void;
+    /** Flush a pending thinking buffer (text deltas interleave with thinking). */
+    flushThinkingDelta(): void;
+    /** Flush every pending buffer — call at iteration boundaries and shutdown. */
+    flushAllStreamBuffers(): void;
+}
+export declare function createStreamCoalescer(deps: StreamCoalescerDeps): StreamCoalescer;
+//# sourceMappingURL=stream-coalescer.d.ts.map

package/dist/webui-server/stream-coalescer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-coalescer.d.ts","sourceRoot":"","sources":["../../src/webui-server/stream-coalescer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,MAAM,WAAW,mBAAmB;IAClC,6EAA6E;IAC7E,SAAS,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAC;IAC7D,kFAAkF;IAClF,cAAc,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,KAAK,CAAC,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9F;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;CACjE;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACnE,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACvE,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IACtD,8EAA8E;IAC9E,kBAAkB,IAAI,IAAI,CAAC;IAC3B,8EAA8E;IAC9E,qBAAqB,IAAI,IAAI,CAAC;CAC/B;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,GAAG,eAAe,CA2JhF"}

package/dist/webui-server/ws-handlers/agent-config.d.ts

@@ -0,0 +1,47 @@
+import { type Agent, type ModelsRegistry, type ModeStore } from '@wrongstack/core';
+import type { WebSocket } from 'ws';
+import type { WsCommon } from './index.js';
+/**
+ * PR 5e of Issue #30: agent-configuration WebSocket handlers —
+ * `modes.list` / `mode.switch` (agent mode) and `model.switch` /
+ * `model.refine` (provider+model). The first three re-broadcast a fresh
+ * `session.start` so every browser tab reflects the change.
+ *
+ * The session.start payload is built by `runWebUI`'s closure
+ * (`buildSessionStartPayload`, which reads a large amount of run state);
+ * it's threaded in here as the `buildSessionStart` callback rather than
+ * reconstructed. The other former captures (`opts.modeStore`,
+ * `opts.agent`, `opts.globalConfigPath`) are `AgentConfigContext` fields.
+ */
+export interface AgentConfigContext extends WsCommon {
+    /** The running agent — mode/model/provider live on its ctx. */
+    agent: Agent;
+    /** Mode store backing modes.list / mode.switch (optional). */
+    modeStore: ModeStore | undefined;
+    /** Global config path — model.switch reads saved provider configs from it. */
+    globalConfigPath: string | undefined;
+    /** Build the session.start payload (runWebUI's closure), broadcast on a config change. */
+    buildSessionStart: (overrides?: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * Models registry, used to look up the active model's reasoning capabilities
+     * so the prompt refiner can send a gated low-effort hint. Optional — when
+     * absent the refiner sends no reasoning field (unchanged behavior).
+     */
+    modelsRegistry?: ModelsRegistry | undefined;
+    onMaxContextResolved?: ((providerId: string, modelId: string, maxContext: number) => void) | undefined;
+    /**
+     * Persist durable keys to config.json (runWebUI's createPrefsSeeding closure).
+     * Used by model.switch to write the new provider+model so the choice survives
+     * restart — parity with the standalone server. Optional: when absent the
+     * switch still applies live, it just doesn't persist.
+     */
+    persistPrefs?: ((payload: Record<string, unknown>) => Promise<void>) | undefined;
+}
+export declare function handleModesList(ctx: AgentConfigContext, ws: WebSocket): Promise<void>;
+export declare function handleModeSwitch(ctx: AgentConfigContext, ws: WebSocket, id: string): Promise<void>;
+export declare function handleModelSwitch(ctx: AgentConfigContext, ws: WebSocket, payload: {
+    provider: string;
+    model: string;
+}): Promise<void>;
+export declare function handleModelRefine(ctx: AgentConfigContext, ws: WebSocket, text: string): Promise<void>;
+//# sourceMappingURL=agent-config.d.ts.map

package/dist/webui-server/ws-handlers/agent-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-config.d.ts","sourceRoot":"","sources":["../../../src/webui-server/ws-handlers/agent-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,KAAK,EAGV,KAAK,cAAc,EACnB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,kBAAmB,SAAQ,QAAQ;IAClD,+DAA+D;IAC/D,KAAK,EAAE,KAAK,CAAC;IACb,8DAA8D;IAC9D,SAAS,EAAE,SAAS,GAAG,SAAS,CAAC;IACjC,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,0FAA0F;IAC1F,iBAAiB,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7E;;;;OAIG;IACH,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAC5C,oBAAoB,CAAC,EACjB,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC,GACnE,SAAS,CAAC;IACd;;;;;OAKG;IACH,YAAY,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;CAClF;AAMD,wBAAsB,eAAe,CAAC,GAAG,EAAE,kBAAkB,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAiC3F;AAED,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,kBAAkB,EACvB,EAAE,EAAE,SAAS,EACb,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,kBAAkB,EACvB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3C,OAAO,CAAC,IAAI,CAAC,CAkDf;AAED,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,kBAAkB,EACvB,EAAE,EAAE,SAAS,EACb,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CA0Df"}

package/dist/webui-server/ws-handlers/brain.d.ts

@@ -0,0 +1,43 @@
+import type { BrainArbiter, BrainAutoRisk, BrainRuntime } from '@wrongstack/core';
+import type { WebSocket } from 'ws';
+import type { WsCommon } from './index.js';
+/**
+ * PR 5b of Issue #30: Brain WebSocket handlers (`brain.status` /
+ * `brain.risk` / `brain.ask`).
+ *
+ * Extracted from the `runWebUI` switch. The former closure captures —
+ * `opts.brainSettings`, `opts.getBrainLog`, and the
+ * `opts.brain ?? container.resolve(TOKENS.BrainArbiter)` lookup — are now
+ * fields on `BrainHandlerContext`. The arbiter resolution is passed as a
+ * thunk so this module needn't know about the agent container or tokens.
+ */
+/** A single Brain decision-log entry (newest last). */
+export interface BrainLogEntry {
+    at: number;
+    kind: string;
+    question: string;
+    outcome: string;
+}
+export interface BrainHandlerContext extends WsCommon {
+    /** Shared autonomy ceiling — the SAME object `/brain` mutates. */
+    brainSettings: {
+        maxAutoRisk: BrainAutoRisk;
+    } | undefined;
+    /**
+     * Live-editable Brain config owner. Powers `brain.config.get/set` and
+     * enriches `brain.status`; risk-only hosts may leave it undefined.
+     */
+    brainRuntime?: BrainRuntime | undefined;
+    /** Read the host's rolling Brain decision log, or undefined when not wired. */
+    getBrainLog: (() => BrainLogEntry[]) | undefined;
+    /** Resolve the active Brain arbiter (host instance, else container-bound), or undefined. */
+    resolveArbiter: () => BrainArbiter | undefined;
+    /** Read the active session id for brain.ask requests. */
+    getSessionId?: (() => string | undefined) | undefined;
+}
+export declare function handleBrainStatus(ctx: BrainHandlerContext, ws: WebSocket): void;
+export declare function handleBrainConfigGet(ctx: BrainHandlerContext, ws: WebSocket): void;
+export declare function handleBrainConfigSet(ctx: BrainHandlerContext, ws: WebSocket, payload: unknown): Promise<void>;
+export declare function handleBrainRisk(ctx: BrainHandlerContext, ws: WebSocket, level: string): void;
+export declare function handleBrainAsk(ctx: BrainHandlerContext, ws: WebSocket, question: string | undefined): Promise<void>;
+//# sourceMappingURL=brain.d.ts.map

package/dist/webui-server/ws-handlers/brain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brain.d.ts","sourceRoot":"","sources":["../../../src/webui-server/ws-handlers/brain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAoB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACpG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C;;;;;;;;;GASG;AAEH,uDAAuD;AACvD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAoB,SAAQ,QAAQ;IACnD,kEAAkE;IAClE,aAAa,EAAE;QAAE,WAAW,EAAE,aAAa,CAAA;KAAE,GAAG,SAAS,CAAC;IAC1D;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC,+EAA+E;IAC/E,WAAW,EAAE,CAAC,MAAM,aAAa,EAAE,CAAC,GAAG,SAAS,CAAC;IACjD,4FAA4F;IAC5F,cAAc,EAAE,MAAM,YAAY,GAAG,SAAS,CAAC;IAC/C,yDAAyD;IACzD,YAAY,CAAC,EAAE,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;CACvD;AAMD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,mBAAmB,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI,CAkB/E;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,mBAAmB,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI,CASlF;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,mBAAmB,EACxB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC,CAmCf;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,mBAAmB,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAe5F;AAED,wBAAsB,cAAc,CAClC,GAAG,EAAE,mBAAmB,EACxB,EAAE,EAAE,SAAS,EACb,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAAC,IAAI,CAAC,CA6Bf"}