@wrongstack/webui-server 0.313.1 → 0.316.2

package/dist/server/pending-confirms.d.ts

@@ -19,6 +19,32 @@ export interface PendingConfirm {
     payload?: Record<string, unknown> | undefined;
 }
 export declare function isDestructivePendingConfirm(confirm: PendingConfirm): boolean;
-export declare function resolveYoloEligiblePendingConfirms(pendingConfirms: Map<string, PendingConfirm>): void;
+/**
+ * Answer "yes" to the prompts YOLO now covers — for ONE session.
+ *
+ * `pendingConfirms` is one process-wide map holding the prompts of every open
+ * tab. YOLO is a per-tab preference, so sweeping the whole map meant turning
+ * it on in one tab silently approved the tool waiting on a prompt in another —
+ * a conversation the user was not even looking at. Passing no session keeps
+ * the old blanket behaviour for single-session hosts.
+ */
+export declare function resolveYoloEligiblePendingConfirms(pendingConfirms: Map<string, PendingConfirm>, sessionId?: string | undefined): void;
 export declare function resolveAllPendingConfirms(pendingConfirms: Map<string, PendingConfirm>, decision: ConfirmDecision): void;
+/**
+ * Answer the prompts of a session that no surface displays any more.
+ *
+ * A permission prompt raised in a background tab is PARKED on that tab's lane
+ * (`chat.setPendingConfirm`). Closing the tab disposes the lane, so the parked
+ * prompt is gone from the client while the server's resolver stays pending
+ * forever — `agent.run` never settles, its run lock is never released, and the
+ * session becomes an unkillable ghost: `session.delete` refuses it with "an
+ * agent run is active" and `retireUndisplayedSessions` skips it. The blanket
+ * `resolveAllPendingConfirms` drain only fires when the LAST socket goes away,
+ * which never happens while the other three tabs are open.
+ *
+ * `no` (not `deny`) on purpose: the tool fails this once and the model can
+ * react, without minting a session-scoped denial for a tool+pattern the user
+ * never actually refused.
+ */
+export declare function resolvePendingConfirmsForSession(pendingConfirms: Map<string, PendingConfirm>, sessionId: string, decision?: ConfirmDecision): number;
 //# sourceMappingURL=pending-confirms.d.ts.map

package/dist/server/port-utils.d.ts

@@ -52,7 +52,7 @@ export declare function getSurfaceDefaultPorts(surface: SurfaceKind): {
 };
 /** Resolve true when `port` can be bound on `host`, false on EADDRINUSE/EACCES. */
 export declare function isPortFree(host: string, port: number): Promise<boolean>;
-export interface FindFreePortOptions {
+interface FindFreePortOptions {
     /** Ports to skip even if free (e.g. one already chosen for the sibling server). */
     exclude?: Set<number> | undefined;
     /** How many consecutive ports to try before giving up. Default 200. */
@@ -63,9 +63,17 @@ export interface FindFreePortOptions {
  * `exclude`. Throws if nothing is free within `maxTries` steps.
  */
 export declare function findFreePort(host: string, startPort: number, opts?: FindFreePortOptions): Promise<number>;
-export interface ListenWithRetryOptions {
+interface ListenWithRetryOptions {
     /** Bind attempts before giving up on EADDRINUSE. Default 10. */
     maxTries?: number | undefined;
+    /**
+     * Same-port re-binds attempted before advancing, when the pre-bind probe
+     * said the port was free and the real bind still reported EADDRINUSE.
+     * Default 2 (see the phantom-EADDRINUSE note in `listenWithRetry`).
+     */
+    phantomRetries?: number | undefined;
+    /** Delay between those same-port re-binds, ms. Default 30. */
+    phantomRetryDelayMs?: number | undefined;
 }
 /**
  * Listen `server` on `host` starting at `port`, advancing one port on each
@@ -74,6 +82,12 @@ export interface ListenWithRetryOptions {
  * error (EACCES, EAFNOSUPPORT, …) rejects immediately; EADDRINUSE past the
  * final attempt rejects with the last error. Resolves with the port the
  * server actually bound, which exceeds the request when a retry advanced.
+ *
+ * Two hazards this must survive, both observed under Bun on Windows:
+ * - a co-listener that throws from the server's 'error' emit (see the
+ *   prependOnceListener note below) — settlement must not depend on it;
+ * - a phantom EADDRINUSE on a port the pre-bind probe just released.
  */
 export declare function listenWithRetry(server: net.Server, host: string, port: number, opts?: ListenWithRetryOptions): Promise<number>;
+export {};
 //# sourceMappingURL=port-utils.d.ts.map

package/dist/server/pref-helpers.d.ts

@@ -17,7 +17,7 @@
  */
 import type { SecretVault } from '@wrongstack/core/types';
 /** Pref keys exposed to the settings panel via prefs.get / prefs.updated. */
-export declare const PREF_KEYS: readonly ['autonomy', 'autonomyDelayMs', 'autoProceedMaxIterations', 'yolo', 'maxIterations', 'chime', 'confirmExit', 'nextPrediction', 'nextStepsTool', 'enhanceEnabled', 'enhanceDelayMs', 'enhanceLanguage', 'featureMcp', 'featurePlugins', 'featureMemory', 'featureSkills', 'featureModelsRegistry', 'indexOnStart', 'contextAutoCompact', 'contextStrategy', 'contextMode', 'tokenSavingTier', 'maxConcurrent', 'titleAnimation', 'uiLocale', 'logLevel', 'auditLevel', 'hqEnabled', 'hqUrl', 'hqRawContent', 'tgConfigured', 'tgSessionEnd', 'tgDelegate', 'tgLongToolMs', 'reasoningMode', 'reasoningEffort', 'reasoningPreserve', 'cacheTtl', 'fallbackModels', 'fallbackProfiles', 'favoriteModels', 'favoriteModelsOnly', 'modelAvailabilitySchedule', 'modelMatrix', 'fallbackAuto', 'refinerProvider', 'refinerModel', 'refinerFallbackProfile', 'thinkingWord', 'statuslineMode', 'animationStyle', 'showModelReasoning', 'breakerEnabled', 'breakerAutoKillResetMs', 'fsAccess', 'debugStream', 'chimeraEnabled', 'chimeraProvider', 'chimeraModel', 'chimeraMaxFiles', 'chimeraAutoFix', 'autoReviewEnabled', 'autoReviewProvider', 'autoReviewModel', 'autoReviewFallbackProfile', 'autoReviewModelSelection', 'autoReviewFallbackModels', 'autoReviewDebounceMs', 'autoReviewMaxFilesPerBatch', 'autoReviewMaxConcurrentReviews', 'autoReviewCascadeOn', 'groupToolCalls', 'showThinkingLogs', 'autoCollapseInput', 'pluginsEnabled', 'fleetChatVerbosity', 'wrongProxyEnabled', 'wrongProxyUrl'];
+export declare const PREF_KEYS: readonly ['autonomy', 'autonomyDelayMs', 'autoProceedMaxIterations', 'yolo', 'maxIterations', 'chime', 'confirmExit', 'nextPrediction', 'nextStepsTool', 'enhanceEnabled', 'enhanceDelayMs', 'enhanceLanguage', 'featureMcp', 'featurePlugins', 'featureMemory', 'featureSkills', 'featureModelsRegistry', 'indexOnStart', 'contextAutoCompact', 'contextStrategy', 'contextMode', 'tokenSavingTier', 'systemPromptVariant', 'maxConcurrent', 'titleAnimation', 'uiLocale', 'logLevel', 'auditLevel', 'hqEnabled', 'hqUrl', 'hqRawContent', 'tgConfigured', 'tgSessionEnd', 'tgDelegate', 'tgLongToolMs', 'reasoningMode', 'reasoningEffort', 'reasoningPreserve', 'cacheTtl', 'fallbackModels', 'fallbackProfiles', 'favoriteModels', 'favoriteModelsOnly', 'modelAvailabilitySchedule', 'modelMatrix', 'modelTiers', 'fallbackAuto', 'refinerProvider', 'refinerModel', 'refinerFallbackProfile', 'thinkingWord', 'statuslineMode', 'animationStyle', 'showModelReasoning', 'breakerEnabled', 'breakerAutoKillResetMs', 'fsAccess', 'debugStream', 'chimeraEnabled', 'chimeraProvider', 'chimeraModel', 'chimeraMaxFiles', 'chimeraAutoFix', 'autoReviewEnabled', 'autoReviewProvider', 'autoReviewModel', 'autoReviewFallbackProfile', 'autoReviewModelSelection', 'autoReviewFallbackModels', 'autoReviewDebounceMs', 'autoReviewMaxFilesPerBatch', 'autoReviewMaxConcurrentReviews', 'autoReviewCascadeOn', 'groupToolCalls', 'showThinkingLogs', 'autoCollapseInput', 'pluginsEnabled', 'fleetChatVerbosity', 'wrongProxyEnabled', 'wrongProxyUrl', 'showAgentSwarmPanel', 'readSymbols', 'showSageMemoryInject', 'sageMemoryInjectThreshold', 'preRefineSeconds', 'multiDiffSummaryThreshold', 'enhanceCountdownMs', 'keyboardShortcuts'];
 export interface PrefHelperDeps {
     /** Path to the active profile config; the sole settings mutation target. */
     profileConfigPath: string;

package/dist/server/prefs-handlers.d.ts

@@ -1,15 +1,44 @@
 import type { ConfigStore } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
 import { type PendingConfirm } from './pending-confirms.js';
+import { type SystemPromptSurface } from './system-prompt-handlers.js';
 import type { WSServerMessage } from './types.js';
+export { SESSION_SCOPED_PREF_KEYS } from './session-scoped-prefs.js';
 export interface PrefsHandlerContext {
     meta: Record<string, unknown>;
-    snapshot: () => Record<string, unknown>;
+    /**
+     * Meta bag of a specific session, for the session-scoped keys above.
+     * Falls back to the process-wide `meta` when the host has not wired
+     * per-session contexts (the embedded single-session runtimes).
+     */
+    metaFor?: ((sessionId?: string) => Record<string, unknown>) | undefined;
+    /**
+     * Read the pref snapshot for ONE session. The session-scoped keys live on
+     * that session's meta, so a snapshot taken without an id describes whichever
+     * session the runtime is on — which is a different tab from the asking one
+     * as often as not once four are open.
+     */
+    snapshot: (sessionId?: string) => Record<string, unknown>;
     persist: (payload: Record<string, unknown>) => Promise<void>;
     pendingConfirms: Map<string, PendingConfirm>;
     configStore?: ConfigStore | undefined;
-    setYolo?: ((enabled: boolean) => void) | undefined;
-    setAutonomy?: ((mode: string) => void) | undefined;
+    /**
+     * Flip the host's process-wide YOLO fallback.
+     *
+     * `sessionId` names the tab that asked. A host whose "apply" path also
+     * writes a context meta must NOT write the leader's when a tab is named —
+     * the leader context is the boot tab's runtime, so that write would turn
+     * YOLO on for a conversation the user was not in.
+     */
+    setYolo?: ((enabled: boolean, sessionId?: string | undefined) => void) | undefined;
+    /**
+     * Flip the RUNTIME autonomy mode. Session-scoped for the same reason
+     * `setYolo` is: the mode is a per-tab preference, and the runtime knob
+     * behind this seam is process-wide, so an unaddressed call let a background
+     * tab put the whole process — and every other tab's system prompt — into
+     * eternal mode.
+     */
+    setAutonomy?: ((mode: string, sessionId?: string | undefined) => void) | undefined;
     applyConfigPrefs?: ((payload: Record<string, unknown>) => void) | undefined;
     setAutoCompact?: ((enabled: boolean) => void) | undefined;
     setLogLevel?: ((level: 'debug' | 'info' | 'warn' | 'error') => void) | undefined;
@@ -23,10 +52,18 @@ export interface PrefsHandlerContext {
      * prefs-dependent request (e.g. an immediate model.switch).
      */
     applyWrongProxyPrefs?: ((payload: Record<string, unknown>) => void | Promise<void>) | undefined;
+    /**
+     * Identity-prompt picker. Optional so a host that has not wired it still
+     * compiles; `system_prompt.get` then answers with an explicit "unavailable"
+     * payload rather than leaving the browser's request unanswered.
+     */
+    systemPrompt?: SystemPromptSurface | undefined;
     send: (ws: WebSocket, message: WSServerMessage) => void;
     broadcast: (message: WSServerMessage) => void;
 }
-export declare function handlePrefsGet(ctx: PrefsHandlerContext, ws: WebSocket): void;
-export declare function handlePrefsUpdate(ctx: PrefsHandlerContext, ws: WebSocket, input: Record<string, unknown>): Promise<void>;
-export declare function handleAutonomySwitch(ctx: PrefsHandlerContext, ws: WebSocket, mode: string): void;
+export declare function handlePrefsGet(ctx: PrefsHandlerContext, ws: WebSocket, sessionId?: string): void;
+/** Answer `system_prompt.get` with the variant catalogue and token estimates. */
+export declare function handleSystemPromptGet(ctx: PrefsHandlerContext, ws: WebSocket, sessionId?: string): Promise<void>;
+export declare function handlePrefsUpdate(ctx: PrefsHandlerContext, ws: WebSocket, input: Record<string, unknown>, sessionId?: string): Promise<void>;
+export declare function handleAutonomySwitch(ctx: PrefsHandlerContext, ws: WebSocket, mode: string, sessionId?: string): void;
 //# sourceMappingURL=prefs-handlers.d.ts.map

package/dist/server/prefs-routes.d.ts

@@ -2,8 +2,8 @@ import type { WebSocket } from 'ws';
 import { type PrefsHandlerContext } from './prefs-handlers.js';
 import type { WSClientMessage } from './types.js';
 export interface PrefsRouteHandlers {
-    /** Respond to the WS client with the current pref snapshot. */
-    getPrefs: (ws: WebSocket) => Promise<void>;
+    /** Respond to the WS client with one session's pref snapshot. */
+    getPrefs: (ws: WebSocket, sessionId?: string) => Promise<void>;
     /**
      * Merge the supplied pref payload into context.meta, persist the durable
      * keys to config.json, apply any runtime effects (YOLO toggle, feature-flag
@@ -11,6 +11,14 @@ export interface PrefsRouteHandlers {
      * logger.level), then broadcast the full current snapshot to all clients.
      */
     updatePrefs: (ws: WebSocket, payload: Record<string, unknown>) => Promise<void>;
+    /**
+     * Reply with the identity-prompt variant catalogue: label, hint and an
+     * upper-bound token estimate per variant, plus which one is live and whether
+     * the user has ever chosen. Setting a variant goes through `prefs.update`
+     * with `systemPromptVariant`, so this side stays read-only.
+     */
+    /** `sessionId` names the tab asking: the live variant is per session. */
+    getSystemPrompt: (ws: WebSocket, sessionId?: string | undefined) => Promise<void>;
     /** Preview/apply canonical defaults in the active profile config. */
     doctorConfig?: ((ws: WebSocket, apply: boolean) => Promise<void>) | undefined;
 }
@@ -24,6 +32,7 @@ export declare function createPrefsRouteHandlers(ctx: PrefsHandlerContext, docto
  * Owned prefixes:
  *   - `prefs.get`
  *   - `prefs.update`
+ *   - `system_prompt.get`
  *   - `config.doctor`
  *
  * Regression-tested by packages/webui/tests/server/dispatcher-routing.test.ts.

package/dist/server/process-handlers.d.ts

@@ -2,21 +2,28 @@
  * Process-registry WebSocket handlers for the WebUI server, extracted from the
  * `handleMessage` switch in `index.ts` as part of splitting that file (#31).
  *
- *   case 'process.list':    return handleProcessList(ws);
+ *   case 'process.list':    return handleProcessList(ws, msg);
  *   case 'process.kill':    return handleProcessKill(ws, msg.payload);
- *   case 'process.killAll': return handleProcessKillAll(ws);
+ *   case 'process.killAll': return handleProcessKillAll(ws, …, msg.payload);
+ *
+ * Four tabs share one registry. A list/kill that ignores sessionId lets tab 2
+ * see (and terminate) tab 1's bash. When the request names a session, list
+ * and kill-all are confined to that session's children; a kill of a PID that
+ * belongs to a different session is refused.
  *
  * Registry failures never escape the handler; they are reported over the
  * socket using the existing protocol envelopes.
  */
-import type { Logger } from '@wrongstack/core/types';
 import { type TrustBoundary } from '@wrongstack/core/security';
+import type { Logger } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
 import { type WebUIPrivilegedAction } from './privileged-actions.js';
 /** Broadcast the tracked-process list; an empty list on any registry failure. */
-export declare function handleProcessList(ws: WebSocket): void;
+export declare function handleProcessList(ws: WebSocket, msg?: {
+    payload?: unknown;
+}): void;
 /** Kill one tracked PID. Rejects invalid payloads and protected processes. */
 export declare function handleProcessKill(ws: WebSocket, payload: unknown, trustBoundary?: TrustBoundary, logger?: Logger | undefined, metadata?: WebUIPrivilegedAction['metadata'] | undefined): Promise<void>;
 /** Kill every tracked process. */
-export declare function handleProcessKillAll(ws: WebSocket, trustBoundary?: TrustBoundary, logger?: Logger | undefined, metadata?: WebUIPrivilegedAction['metadata'] | undefined): Promise<void>;
+export declare function handleProcessKillAll(ws: WebSocket, trustBoundary?: TrustBoundary, logger?: Logger | undefined, metadata?: WebUIPrivilegedAction['metadata'] | undefined, payload?: unknown): Promise<void>;
 //# sourceMappingURL=process-handlers.d.ts.map

package/dist/server/project-handlers.d.ts

@@ -41,6 +41,18 @@ export interface ProjectHandlersContext {
     onSessionSwapped?: (sessionId: string, target?: SessionIdentityTarget) => void | Promise<void>;
     allowProjectMutations?: boolean;
     sessionStartPayload: (overrides?: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * Deliver to EVERY connection, bypassing the session filter.
+     *
+     * Both hosts now route a broadcast by the `sessionId` on its payload, which
+     * is right for everything that describes one tab and wrong for the project
+     * switch: it announces a session created a millisecond ago, so no client can
+     * be subscribed to it and the filter dropped the switch on the floor —
+     * exactly the "changed NOTHING in the browser" failure this handler exists
+     * to prevent. Optional; falls back to the plain broadcast for hosts that do
+     * not filter.
+     */
+    broadcastEveryone?: (message: OutboundMessage) => void;
 }
 export declare function createProjectHandlers(ctx: ProjectHandlersContext): ProjectRouteHandlers;
 export {};

package/dist/server/project-watcher.d.ts

@@ -3,19 +3,27 @@
  * files are created, modified, or deleted inside the project root, so
  * the WebUI file explorer refreshes its tree without manual navigation.
  *
- * Uses Node's native `fs.watch` with `recursive: true` (supported on
- * Windows and macOS; Linux support landed in Node 22). Events are
- * debounced (400ms) to coalesce bursts from build tools, git
- * checkouts, and agent writes. Heavyweight directories
- * (`node_modules`, `.git`, `dist`, …) are ignored to avoid event
- * storms — the same `SKIP_DIRS` set the tree builder uses.
+ * Subscribes to core's SHARED recursive project watcher rather than opening
+ * its own. This file used to call `fs.watch(root, {recursive:true})` directly,
+ * which meant a running WebUI put a SECOND recursive watch on the same tree:
+ * the OS then tracked it independently and delivered every event twice — and
+ * on Windows `ReadDirectoryChangesW` reports `node_modules` too, so a `pnpm
+ * install` or a build paid that twice over. Core's registry keeps ONE watcher
+ * per resolved root per process and fans out to subscribers, which is exactly
+ * why it exists; the codebase indexer and the chronicle file observer were
+ * already using it.
  *
- * The watcher is `persistent: false` and `unref`'d on each handle so
- * it does not keep the process alive. The returned disposer closes
- * all native handles.
+ * Events are debounced (400ms) to coalesce bursts from build tools, git
+ * checkouts, and agent writes. Heavyweight directories (`node_modules`,
+ * `.git`, `dist`, …) are ignored to avoid event storms — the same `SKIP_DIRS`
+ * set the tree builder uses.
+ *
+ * The shared watcher is non-persistent and never keeps the process alive. The
+ * returned disposer drops this subscription; the underlying handle closes once
+ * the last subscriber leaves.
  */
 import type { ConnectedClient, WSServerMessage } from './types.js';
-export interface ProjectWatcherDeps {
+interface ProjectWatcherDeps {
     /** Absolute project root to watch. */
     projectRoot: string;
     /** Broadcast a message to all connected WS clients. */
@@ -28,4 +36,5 @@ export interface ProjectWatcherDeps {
  * disposer that closes all native watch handles.
  */
 export declare function startProjectWatcher(deps: ProjectWatcherDeps): () => void;
+export {};
 //# sourceMappingURL=project-watcher.d.ts.map

package/dist/server/provider/mutations.d.ts

@@ -30,5 +30,4 @@ export interface ProviderServiceContext {
     broadcastSaved(providers: Record<string, ProviderConfig>): void;
 }
 export declare function createProviderServiceContext(deps: ProviderOperationsDeps): ProviderServiceContext;
-export type { ProviderServiceContext as ProviderMutationsContext };
 //# sourceMappingURL=mutations.d.ts.map

package/dist/server/provider-fanout.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Give every conversation the rebuilt provider.
+ *
+ * A WrongProxy toggle and a credential hot-reload are PROJECT-wide facts: the
+ * same provider, rebuilt with a different base URL or a new key. Both used to
+ * assign the result to the root context alone.
+ *
+ * That is enough for a host with one conversation and wrong for four. A
+ * session's `Context` is created with the root's provider REFERENCE, so every
+ * tab opened before the toggle kept running the old object — routed the old
+ * way, authenticated with the old key — while the leader used the new one.
+ * Nothing on screen distinguishes them, and the divergence lasts until each
+ * tab happens to switch models.
+ *
+ * The fan-out is deliberately conservative: only contexts still pointing at
+ * the exact provider object being replaced are moved. A tab that chose its own
+ * model owns its own provider and must keep it — that choice is per
+ * conversation, and overwriting it here would be the very cross-tab write this
+ * exists to prevent.
+ *
+ * @module provider-fanout
+ */
+import type { Context } from '@wrongstack/core/agent';
+import type { Provider } from '@wrongstack/core/types';
+interface ProviderFanoutInput {
+    /** Conversations holding a live agent; absent on single-conversation hosts. */
+    sessionAgentIds?: (() => string[]) | undefined;
+    /** Read-only agent lookup — must never materialise one. */
+    peekAgent?: ((sessionId?: string) => {
+        ctx: Context;
+    } | undefined) | undefined;
+    /** The provider object being replaced. */
+    previous: Provider | undefined;
+    /** The rebuilt provider. */
+    next: Provider;
+    /** The context that already received `next` and must not be revisited. */
+    applied: Context;
+}
+/**
+ * Move every other conversation off `previous` and onto `next`.
+ *
+ * Returns the session ids that were moved, for logging and tests.
+ */
+export declare function fanOutProviderRebuild(input: ProviderFanoutInput): string[];
+export {};
+//# sourceMappingURL=provider-fanout.d.ts.map

package/dist/server/provider-handlers.d.ts

@@ -49,7 +49,7 @@ export declare function createProviderOperations(deps: ProviderOperationsDeps):
     broadcastSaved: (providers: Record<string, ProviderConfig>) => void;
     loadConfigProviders: () => Promise<Record<string, ProviderConfig>>;
 };
-export interface ProviderHandlerDeps {
+interface ProviderHandlerDeps {
     /** Path to the active profile config; the only provider mutation target. */
     profileConfigPath: string;
     vault: import('@wrongstack/core/types').SecretVault;
@@ -57,7 +57,11 @@ export interface ProviderHandlerDeps {
     setConfigWriteLock: (lock: Promise<void>) => void;
     getConfigWriteLock: () => Promise<void>;
     /** Broadcast a message to all connected WebUI clients */
-    broadcast: (clients: Map<WebSocket, ConnectedClient>, msg: WSServerMessage) => void;
+    broadcast: (clients: Map<WebSocket, ConnectedClient>, msg: WSServerMessage, 
+    /** Deliver to the tab that owns this session, overriding the id on the
+     *  payload. Needed when the payload names a SUBAGENT's session, which no
+     *  tab subscribes to. */
+    targetSessionId?: string) => void;
     /** Connected WebUI clients map */
     clients: Map<WebSocket, ConnectedClient>;
     /** Used by the ChatGPT OAuth flow's tier-2 model lookup (best-effort). */

package/dist/server/provider-routes.d.ts

@@ -48,6 +48,9 @@ export interface ProviderRouteHandlers {
     /** Live provider/model health tracker (the "waiting room"). Undefined when
      * the host is not wired with a tracker (e.g. test harnesses). */
     statusTracker?: ProviderModelStatusTracker | undefined;
+    /** Durable block/open audit trail (JSONL) next to the profile config.
+     * Undefined when the host did not provide a profile path (test harnesses). */
+    providerAuditFile?: string | undefined;
 }
 export declare function handleProviderRoute(ws: WebSocket, msg: WSClientMessage, routes: ProviderRouteHandlers): Promise<boolean>;
 export {};

package/dist/server/provider-store.d.ts

@@ -1,6 +1,6 @@
 import type { DefaultSecretVault } from '@wrongstack/core/security';
 import type { ProviderApiKey, ProviderConfig } from '@wrongstack/core/types';
-export interface ProviderStoreDeps {
+interface ProviderStoreDeps {
     /** Active profile config path. */
     profileConfigPath: string;
     vault: DefaultSecretVault;
@@ -24,4 +24,5 @@ export interface ProviderStore {
     maskedKey(key: string | undefined): string;
 }
 export declare function createProviderStore(deps: ProviderStoreDeps): ProviderStore;
+export {};
 //# sourceMappingURL=provider-store.d.ts.map

package/dist/server/requirement-intake-handlers.d.ts

@@ -19,8 +19,6 @@
  */
 import type * as http from 'node:http';
 import { type RequirementIntakeService } from '@wrongstack/requirement-intake';
-/** Map a domain error to an HTTP status + JSON error body. */
-export declare function sendIntakeError(res: http.ServerResponse, error: unknown): void;
 /**
  * List intake records for the server's own project. The webui-server serves
  * one project; the canonical `proj_<ulid>` id lives in `.wrongstack/project.json`,

package/dist/server/route-family-dispatcher.d.ts

@@ -2,6 +2,7 @@ import type { WebSocket } from 'ws';
 import { type AgentRosterRouteHandlers } from './agent-roster-routes.js';
 import { type AutonomyRouteHandlers } from './autonomy-routes.js';
 import { type BrainRouteHandlers } from './brain-routes.js';
+import { type ChimeraRouteHandlers } from './chimera-routes.js';
 import { type ChronicleRouteContext } from './chronicle-routes.js';
 import { type ClientTransportRouteHandlers } from './client-transport-routes.js';
 import { type CompletionRouteHandlers } from './completion-routes.js';
@@ -40,6 +41,7 @@ export interface RouteFamilyTable {
     mode: ModeRouteHandlers;
     prefs: PrefsRouteHandlers;
     brain: BrainRouteHandlers;
+    chimera: ChimeraRouteHandlers | undefined;
     worklist: WorklistRouteHandlers;
     process: ProcessRouteHandlers;
     host: HostRouteHandlers;

package/dist/server/routes.d.ts

@@ -13,6 +13,7 @@ import type { Config } from '@wrongstack/core/types';
 import type { MCPRegistry } from '@wrongstack/mcp';
 import { type AutonomyRouteHandlers } from './autonomy-routes.js';
 import type { BrainRouteHandlers } from './brain-routes.js';
+import { type ChimeraRouteHandlers } from './chimera-routes.js';
 import type { CollaborationWebSocketHandler } from './collaboration-ws-handler.js';
 import type { CustomModeStore } from './custom-context-modes.js';
 import type { GoalRouteHandlers } from './goal-routes.js';
@@ -20,7 +21,7 @@ import type { GoalWebSocketHandler } from './goal-ws-handler.js';
 import { type MailboxRouteHandlers } from './mailbox-routes.js';
 import type { McpRouteHandlers } from './mcp-routes.js';
 import type { ModeRouteHandlers } from './mode-routes.js';
-import type { PendingConfirm } from './pending-confirms.js';
+import { type PendingConfirm } from './pending-confirms.js';
 import { type PrefsRouteHandlers } from './prefs-routes.js';
 import type { ProjectRouteHandlers } from './project-routes.js';
 import type { ProviderRouteHandlers } from './provider-routes.js';
@@ -67,9 +68,17 @@ export interface WebuiMutableState {
      * refactor moves that into the projectHandlers setter chain so the
      * route layer just calls a single hook.
      */
-    abortRunLock: () => void;
-    /** True while the leader agent owns the shared run lock. */
-    isRunActive: () => boolean;
+    abortRunLock: (sessionId?: string) => void;
+    /** True while `sessionId` (or any session, when omitted) owns a run lock. */
+    isRunActive: (sessionId?: string) => boolean;
+    /** Every session id with an in-flight run — one per busy WebUI tab. */
+    getRunningSessionIds: () => string[];
+    /**
+     * Host-wide serialiser for session transitions. Shared by the session
+     * handlers and the conversation ops so run setup never lands on a context
+     * that a concurrent session swap is halfway through re-pointing.
+     */
+    withSessionTransition: <T>(operation: () => Promise<T>) => Promise<T>;
     /** Read-only reference to the live WS clients map. */
     getClients(): Map<WebSocket, ConnectedClient>;
 }
@@ -80,6 +89,27 @@ export interface WebuiMutableState {
 export interface WebuiDeps {
     trustBoundary: import('@wrongstack/core/security').TrustBoundary;
     agent: Agent;
+    getAgent?: ((sessionId?: string) => Agent) | undefined;
+    /**
+     * The Agent for a session WITHOUT creating one. Read-only callers use this;
+     * `getAgent` creates, so asking about a stale id materialises an agent for
+     * it and can evict a live tab's.
+     */
+    peekAgent?: ((sessionId?: string) => Agent | undefined) | undefined;
+    /**
+     * Every conversation currently holding an agent.
+     *
+     * A project-wide provider rebuild (WrongProxy toggle, credential
+     * hot-reload) used to swap `context.provider` and stop there. Session
+     * contexts copy the root's provider REFERENCE when they are created, so
+     * every tab opened before the toggle kept the old, unrouted provider while
+     * the leader used the new one — four tabs, two different providers, no way
+     * to tell from the UI. Hosts with one conversation omit this.
+     */
+    sessionAgentIds?: (() => string[]) | undefined;
+    hasSession?: ((id: string) => boolean) | undefined;
+    /** Does this host already hold an open journal writer for that session? */
+    isSessionLive?: ((id: string) => boolean) | undefined;
     context: Context;
     container: Container;
     toolRegistry: ToolRegistry;
@@ -149,7 +179,12 @@ export interface WebuiDeps {
  * delegates without storing state of its own.
  */
 export interface WebuiCallbacks {
-    sessionStartPayload: () => Promise<{
+    /**
+     * Build a `session.start` payload. `overrides.sessionId` selects WHICH
+     * session it describes — with four tabs live, the runtime's own "current"
+     * session is not necessarily the one being reported on.
+     */
+    sessionStartPayload: (overrides?: Record<string, unknown>) => Promise<{
         sessionId: string;
         model: string;
         provider: string;
@@ -186,6 +221,7 @@ export interface AllRoutes {
     prefsRoutes: PrefsRouteHandlers;
     autonomyRoutes: AutonomyRouteHandlers;
     shellGitRoutes: ShellGitRouteHandlers;
+    chimeraRoutes: ChimeraRouteHandlers;
     mailboxRoutes: MailboxRouteHandlers;
     mcpRoutes: McpRouteHandlers;
     brainRoutes: BrainRouteHandlers;

package/dist/server/sdd-board-ws-handler.d.ts

@@ -7,7 +7,7 @@ interface SddBoardWSMessage {
     payload?: Record<string, unknown>;
 }
 /** Project paths the handler needs to apply lifecycle ops directly. */
-export interface SddBoardLifecycleDeps {
+interface SddBoardLifecycleDeps {
     projectRoot: string;
     /** Explicit compatibility hook for file-codec tests and old integrations. */
     controlTransport?: 'kanban' | 'legacy-file' | undefined;
@@ -20,7 +20,7 @@ export interface SddBoardLifecycleDeps {
         projectSddBoards: string;
     };
 }
-export interface SddBoardSecurityDeps {
+interface SddBoardSecurityDeps {
     trustBoundary: TrustBoundary;
     logger?: Logger | undefined;
 }

package/dist/server/server-runtime.d.ts

@@ -46,13 +46,25 @@ interface SessionStartPayloadGetters {
     getContextMode(): string;
     getNeedsSetup(): boolean;
     modelsRegistry: ModelsRegistry;
+    /**
+     * Resolve a session's own Context. Each WebUI tab runs its own session with
+     * its own model, mode and context strategy; without this the payload would
+     * describe the runtime's current session for every tab.
+     */
+    getSessionContext?: ((sessionId: string) => SessionRuntimeContext | undefined) | undefined;
 }
-/**
- * Build a factory that produces the rich session.start payload from current
- * runtime state. Reads live values through getters so post-/new, post-resume,
- * and post-model.switch all broadcast the same shape.
- */
-export declare function createSessionStartPayload(g: SessionStartPayloadGetters): () => Promise<{
+/** The slice of a session Context this payload reads. */
+interface SessionRuntimeContext {
+    model?: string | undefined;
+    provider?: {
+        id?: string | undefined;
+    } | undefined;
+    session?: {
+        startedAt?: string | undefined;
+    } | undefined;
+    meta?: Record<string, unknown> | undefined;
+}
+export declare function createSessionStartPayload(g: SessionStartPayloadGetters): (overrides?: Record<string, unknown>) => Promise<{
     sessionId: string;
     model: string;
     provider: string;
@@ -69,6 +81,11 @@ export declare function createSessionStartPayload(g: SessionStartPayloadGetters)
     protocolCapabilities: string[];
     needsSetup?: boolean | undefined;
     reasoningEffortLevels?: string[] | undefined;
+    /** Tri-state effort-support signal (see SessionLaneData.effortSupported). */
+    effortSupported?: boolean | undefined;
+    /** Project-wide effort — display-only hint for the composer's auto option. */
+    projectReasoningEffort?: string | undefined;
+    [key: string]: unknown;
 }>;
 interface WsServerResult {
     wssPrimary: WebSocketServer;