@wrongstack/cli 0.313.0 → 0.316.1

package/dist/webui-server/connection-handler.d.ts

@@ -5,7 +5,18 @@ import type { WebSocket } from 'ws';
 import type { WSClientMessage, WSServerMessage } from './contracts.js';
 export interface ConnectedClient {
     ws: WebSocket;
+    /** The session this connection last acted on. */
     sessionId: string | null;
+    /**
+     * EVERY session this connection is displaying, as declared by
+     * `session.subscribe`.
+     *
+     * One browser page holds up to four tabs on ONE socket, so `sessionId` is
+     * only the tab last touched. Anything that asks "is this session still on
+     * someone's screen" — the delete guard, per-tab agent eviction — needs the
+     * whole set, or it treats three open tabs as abandoned.
+     */
+    sessionIds?: Set<string> | undefined;
 }
 export interface ConnectionHandlerDeps {
     host: string;
@@ -27,7 +38,6 @@ export interface ConnectionHandlerDeps {
         sessionId: string;
     };
     handleMessage: (ws: WebSocket, client: ConnectedClient, msg: WSClientMessage) => Promise<void>;
-    abortControllers: Map<string, AbortController>;
     pendingConfirms: Map<string, PendingConfirm>;
     buildSessionStartPayload: (overrides?: Record<string, unknown>, needsSetup?: boolean) => Promise<Record<string, unknown>>;
     loadReplay?: (() => Promise<{
@@ -35,7 +45,29 @@ export interface ConnectionHandlerDeps {
         events?: readonly SessionEvent[] | undefined;
         usage?: Usage | undefined;
     } | null>) | undefined;
-    loadAgentSessions?: (() => Promise<import('@wrongstack/core/coordination').AgentVirtualSession[]>) | undefined;
+    /**
+     * The sessions this RUNTIME currently holds open — the boot session plus any
+     * tab the registry is still keeping alive.
+     *
+     * The browser persists its tab strip in `localStorage`, and on every open it
+     * promoted that list back into live tabs. After the server had restarted
+     * that list is history: none of those ids belong to this process, so a fresh
+     * `wstack --webui` came up wearing the tab strip of some previous run,
+     * fronted a session from days ago, and paid for a FULL journal resume (with
+     * its todo board) before the user had typed anything. Handing the client the
+     * live set lets it keep only the tabs that still exist and start clean
+     * otherwise.
+     */
+    openSessionIds?: (() => string[]) | undefined;
+    /**
+     * Read back NAMED subagents' transcripts.
+     *
+     * `subagentIds` comes from the session's OWN journal, because the
+     * transcripts directory is shared by every session of the project: asked for
+     * everything, this handed each of four open tabs the union of all four tabs'
+     * workers.
+     */
+    loadAgentSessions?: ((subagentIds: readonly string[]) => Promise<import('@wrongstack/core/coordination').AgentVirtualSession[]>) | undefined;
     needsSetup: boolean;
 }
 export declare function createConnectionHandler(deps: ConnectionHandlerDeps): (ws: WebSocket, req: IncomingMessage) => Promise<void>;

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

@@ -17,6 +17,7 @@ interface CliWebUIOptions {
         modelAvailabilitySchedule?: ModelBlackoutRule[] | undefined;
         fallbackAuto?: boolean | undefined;
         modelMatrix?: Config['modelMatrix'] | undefined;
+        modelTiers?: Config['modelTiers'] | undefined;
         uiLocale?: string | undefined;
         /** WrongProxy / WrongTrace toggle. */
         wrongProxyEnabled?: boolean | undefined;
@@ -28,7 +29,16 @@ type PrefSnapshot = Record<string, unknown>;
 export { PREF_KEYS };
 export declare function seedConfigToMeta(opts: CliWebUIOptions): Promise<void>;
 export interface PrefsSeeding {
-    prefSnapshot: () => PrefSnapshot;
+    /**
+     * The preference snapshot for one tab.
+     *
+     * Session-scoped preferences (autonomy, yolo, context strategy, reasoning,
+     * the identity variant…) live on each session's OWN context meta, so a
+     * snapshot built from the leader's meta describes whichever conversation
+     * the leader happens to hold — not the tab that asked. Pass the meta of the
+     * asking session; omit it for a single-session host.
+     */
+    prefSnapshot: (meta?: Record<string, unknown> | undefined) => PrefSnapshot;
     persistPrefs: (payload: PrefSnapshot) => Promise<void>;
 }
 export declare function createPrefsSeeding(opts: CliWebUIOptions): PrefsSeeding;

package/dist/webui-server/route-contexts.d.ts

@@ -3,6 +3,8 @@
  *
  * @module webui-server/route-contexts
  */
+import type { Agent } from '@wrongstack/core/agent';
+import type { SessionWriter } from '@wrongstack/core/types';
 import { type BrainHandlerContext, type CustomModeStore, type DesignContext, type EmbeddedAgentConfigContext, type EmbeddedConversationContext, type EmbeddedProjectContext, type EmbeddedSessionContext, type IntrospectionRouteContext, type PendingConfirm, type PrefsHandlerContext, type PromptsContext, type SkillsContext } from '@wrongstack/webui-server';
 import type { WebSocket } from 'ws';
 import type { CliWebUIOptions } from '../webui-server-options.js';
@@ -16,25 +18,63 @@ export interface RouteContextsParams {
     currentSessionId: () => string;
     getCustomModeStore: () => Promise<CustomModeStore>;
     buildSessionStartPayload: (overrides?: Record<string, unknown>) => Promise<Record<string, unknown>>;
-    prefSnapshot: () => Record<string, unknown>;
+    /** Preference snapshot for one tab's meta; the leader's when none is named. */
+    prefSnapshot: (meta?: Record<string, unknown> | undefined) => Record<string, unknown>;
     persistPrefs: (patch: Record<string, unknown>) => Promise<void>;
     pendingConfirms: Map<string, PendingConfirm>;
     abortControllers: Map<string, AbortController>;
-    getAbortController: () => AbortController | null;
-    clearAbortController: () => void;
+    /**
+     * The Agent that owns one session's runs — one per open tab.
+     *
+     * Handing every tab the single leader Agent is what made a second tab answer
+     * with "Agent.run() is already in progress on this instance": the guard is
+     * right, one instance for four tabs was not.
+     */
+    getSessionAgent: (sessionId?: string | undefined) => Agent;
+    /**
+     * Non-creating registry peek. Feeds the embedded host's `hasSession`
+     * ownership check so asking "can this host serve session X?" never
+     * materializes an agent (the creating `getSessionAgent` did).
+     */
+    peekSessionAgent?: (sessionId?: string | undefined) => Agent | undefined;
+    /** Does the host already hold an open writer for that session? */
+    isSessionLive: (sessionId: string) => boolean;
+    /**
+     * The host's foreground-session pointer. Kept OUT of the leader agent's
+     * context: that context is the boot tab's runtime, and using it as the
+     * pointer made every resume re-point the boot tab.
+     */
+    getForegroundSession: () => SessionWriter;
+    setForegroundSession: (next: SessionWriter) => void;
+    /** Live connections, so `session.subscribe` has somewhere to land. */
+    clients: Map<WebSocket, {
+        sessionId: string | null;
+        sessionIds?: Set<string> | undefined;
+    }>;
+    /** Retire the per-tab agents of sessions nobody is displaying any more. */
+    onSessionsUndisplayed: (sessionIds: string[]) => void;
+    /** Stop the subagents one session spawned, when that session is aborted. */
+    stopSessionFleet?: ((sessionId: string) => void | Promise<void>) | undefined;
     send: (ws: WebSocket, msg: WSServerMessage) => void;
     broadcast: (msg: WSServerMessage) => void;
+    /**
+     * Bypasses the session filter `broadcast` applies. Only the project switch
+     * uses it: that frame names a session created moments earlier, so no
+     * connection can be subscribed to it yet.
+     */
+    broadcastEveryone?: ((msg: WSServerMessage) => void) | undefined;
 }
-export declare function createWebuiRouteContexts({ opts, profileConfigPath, profileDir, globalRoot, sessionStartedAt, currentSessionId, getCustomModeStore, buildSessionStartPayload, prefSnapshot, persistPrefs, pendingConfirms, abortControllers, getAbortController, clearAbortController, send, broadcast, }: RouteContextsParams): {
+export declare function createWebuiRouteContexts({ opts, profileConfigPath, profileDir, globalRoot, sessionStartedAt, currentSessionId, getCustomModeStore, buildSessionStartPayload, prefSnapshot, persistPrefs, pendingConfirms, abortControllers, getSessionAgent, peekSessionAgent, isSessionLive, getForegroundSession, setForegroundSession, clients, onSessionsUndisplayed, stopSessionFleet, send, broadcast, broadcastEveryone, }: RouteContextsParams): {
     brainCtx: BrainHandlerContext;
     introspectionCtx: IntrospectionRouteContext;
     skillsCtx: SkillsContext;
     promptsCtx: PromptsContext;
-    designCtx: DesignContext;
+    designCtx: (sessionId?: string | undefined) => DesignContext;
     agentConfigCtx: EmbeddedAgentConfigContext;
     prefsCtx: PrefsHandlerContext;
     projectsCtx: EmbeddedProjectContext;
     mailboxRoutes: import("@wrongstack/webui-server").MailboxRouteHandlers;
+    chimeraRoutes: import("@wrongstack/webui-server").ChimeraRouteHandlers;
     sessionsCtx: EmbeddedSessionContext;
     connectionCtx: EmbeddedConversationContext;
 };

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

@@ -11,6 +11,19 @@ export interface SessionStartPayloadDeps {
     session: {
         id: string;
     };
+    /**
+     * The Context of ONE session, without creating it.
+     *
+     * `session.start` is sent for a named session — a resume, a background tab's
+     * announce, a model switch in a tab that is not in front — and everything in
+     * the payload (model, provider, context mode, window size, cost rates, the
+     * context-fill estimate) is a property of THAT session, not of whichever
+     * session the leader agent happens to point at. Reading the leader is how a
+     * background tab ended up displaying the foreground tab's model and billing
+     * its tokens at the foreground tab's rates. Falls back to the leader when
+     * the id is unknown, which is exactly the single-session host.
+     */
+    getSessionContext?: ((sessionId: string) => Context | undefined) | undefined;
     modelsRegistry?: ModelsRegistry | undefined;
     statusTracker?: import('@wrongstack/core/coordination').ProviderModelStatusTracker | undefined;
     modeId?: string | undefined;

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

@@ -9,11 +9,24 @@ export interface SetupEventsDeps {
     agent: {
         ctx: Context;
     };
+    /**
+     * The Context of a NAMED session, without creating one.
+     *
+     * Event payloads describe the session that produced them, and the iteration
+     * ceiling they carry is a per-tab setting — read off the leader it told a
+     * background tab it was capped at a number the user set in another tab.
+     */
+    sessionContext?: ((sessionId: string) => Context | undefined) | undefined;
     subscribeEternalIteration?: ((fn: (entry: JournalEntry) => void) => () => void) | undefined;
+    /**
+     * `targetSessionId` names the tab a frame belongs to when the payload's own
+     * `sessionId` is somebody else's (a subagent's). Optional so single-session
+     * embedders can keep passing a one-argument broadcaster.
+     */
     broadcast: (msg: {
         type: string;
         payload: unknown;
-    }) => void;
+    }, targetSessionId?: string) => void;
     sessionPayload: <T extends Record<string, unknown>>(payload: T) => T & {
         sessionId: string;
     };