@wrongstack/webui-server 0.313.0 → 0.316.1

package/dist/server/session-agent-registry.d.ts

@@ -0,0 +1,145 @@
+/**
+ * session-agent-registry.ts — one Agent per open tab.
+ *
+ * `Agent.run()` refuses to run twice on the same instance, and it is right to:
+ * a run mutates `ctx.signal`, `ctx.messages`, the session writer, token
+ * bookkeeping and compaction state, none of which survive two runs racing
+ * through them. So "four tabs running at once" is not a matter of relaxing that
+ * guard — it is a matter of there being four Agents.
+ *
+ * The embedded WebUI host had exactly one, shared by every tab, and handed it
+ * out no matter which session asked. Starting a run in a second tab therefore
+ * hit the guard head-on:
+ *
+ *     [agent.run] Agent.run() is already in progress on this instance.
+ *
+ * This registry is the missing half. It hands each session its own Agent,
+ * cloned from the leader's wiring — same container, tools, providers, events,
+ * pipelines and executor, its own `Context`. Everything shared is deliberately
+ * shared (the tool registry and provider registry are stateless surfaces; the
+ * event bus is how the host observes every tab). Everything per-run is not.
+ */
+import { Agent } from '@wrongstack/core/agent';
+import type { ModelsRegistry, TokenCounter } from '@wrongstack/core/types';
+export interface SessionAgentRegistryOptions {
+    /**
+     * The leader Agent. Supplies both the wiring every session agent inherits
+     * and the identity of the boot session, which keeps using it.
+     */
+    template: Agent;
+    /** Hard ceiling on live agents. Matches the four-tab ceiling. */
+    maxAgents?: number | undefined;
+    /**
+     * Is this session mid-run? Consulted before eviction — a running agent owns
+     * a live transcript that exists nowhere else.
+     */
+    isRunActive?: ((sessionId: string) => boolean) | undefined;
+    /** Called once, right after a new session agent is constructed. */
+    onCreate?: ((agent: Agent, sessionId: string) => void) | undefined;
+    /** Models registry, so a session's own counter can price its own usage. */
+    modelsRegistry?: ModelsRegistry | undefined;
+    /**
+     * Override how a session's Agent is built. The default clones the template's
+     * wiring; a caller that already owns an Agent per session (or a test that
+     * does not want a whole container) supplies its own.
+     */
+    createAgent?: ((sessionId: string) => Agent) | undefined;
+    /**
+     * Is any connected surface currently showing this session?
+     *
+     * Consulted before eviction. Without it the victim is simply the oldest
+     * non-running entry, which is routinely a tab the user still has open while
+     * the agents of tabs they closed minutes ago sit untouched — the open tab
+     * then loses its in-memory transcript and comes back empty.
+     */
+    isDisplayed?: ((sessionId: string) => boolean) | undefined;
+}
+export interface SessionAgentRegistry {
+    /**
+     * The Agent for a session; the leader's when no session is named.
+     *
+     * CREATES one when the id is unknown, so this is for callers that own the
+     * session (a run, a session transition). Read-only callers must use `peek`:
+     * `get` on a stale id materialises an agent and can evict a live one.
+     */
+    get(sessionId?: string | undefined): Agent;
+    /** The Agent for a session, or undefined. Never creates, never evicts. */
+    peek(sessionId?: string | undefined): Agent | undefined;
+    /**
+     * Does this session have an agent with a REAL session writer?
+     *
+     * A freshly created agent carries a placeholder writer until the session
+     * transition that owns the id installs the real one, so `has` alone does not
+     * mean the session can be written to.
+     */
+    isLive(sessionId: string): boolean;
+    has(sessionId: string): boolean;
+    ids(): string[];
+    /** Forget a session's agent, keeping its journal open. */
+    drop(sessionId: string): void;
+    /**
+     * End a session for good: `session_end`, close, forget.
+     *
+     * What a CLOSED TAB gets. `drop` alone left the journal open with no
+     * terminal marker, which is indistinguishable from a journal a crash left
+     * hanging — so every tab the user closed on purpose came back on the
+     * recovery list, and its history entry had no outcome.
+     */
+    endAndClose(sessionId: string): Promise<void>;
+    /**
+     * Drain every open session journal to disk, synchronously.
+     *
+     * For fatal-exit salvage only (crash-shield, `process.on('exit')`). The
+     * per-session writers buffer non-critical records for up to a flush window,
+     * and the host's own salvage hook only knows the LEADER's writer — so a
+     * crash silently truncated the tail of every other open tab.
+     */
+    flushAllSync(): void;
+    /**
+     * End and close every non-leader session journal.
+     *
+     * Clean shutdown only. Without it, quitting a host with three background
+     * tabs left three journals with no trailing `session_end`, which is exactly
+     * how a crash looks: the next launch offered all three for recovery. The
+     * leader's own journal is left alone — its host teardown owns it.
+     */
+    closeAll(): Promise<void>;
+}
+/**
+ * A token counter that answers for ONE session while still feeding the
+ * process-wide one.
+ *
+ * Four tabs shared a single counter, so every per-session question it was
+ * asked came back as the sum of all four: the Inspector's token, cost and
+ * cache figures for a tab, the usage stamped into a session's `session_end`
+ * record, the before/after numbers on a compaction report. Reads here are this
+ * session's own; `account` still forwards, so process-wide consumers (budget
+ * watchdog, shutdown totals, project switch) keep seeing everything.
+ *
+ * Deliberately constructed WITHOUT an event bus: the root counter already
+ * emits `token.accounted` for every call, and a second emitter would double
+ * every downstream tally.
+ */
+export declare function createSessionTokenCounter(opts: {
+    root: TokenCounter;
+    sessionId: string;
+    registry?: ModelsRegistry | undefined;
+    providerId?: (() => string | undefined) | undefined;
+}): TokenCounter;
+/**
+ * The part of the leader's meta a NEW conversation may inherit.
+ *
+ * Host-level facts (mode, feature flags, the resolved window size) describe the
+ * project, so a fresh tab starts configured rather than bare. The
+ * SESSION-SCOPED PREFERENCES are removed, and that is the point: they are
+ * per-conversation by design (YOLO, autonomy, the iteration ceiling, the
+ * context strategy, the Lite/Standard/Pro identity), and the leader's meta is
+ * not the project's copy of them — it is whatever the FIRST TAB last chose.
+ * Copying it started a brand-new conversation under another tab's settings,
+ * YOLO included. Each of those keys already falls back to the project default
+ * when absent, so leaving them off is exactly "starts clean"; the tab's own
+ * first choice writes its own.
+ */
+export declare function inheritedSessionMeta(rootMeta: Record<string, unknown>): Record<string, unknown>;
+export declare function createSessionAgentRegistry(opts: SessionAgentRegistryOptions): SessionAgentRegistry;
+//# sourceMappingURL=session-agent-registry.d.ts.map

package/dist/server/session-agent-sessions.d.ts

@@ -0,0 +1,49 @@
+import type { SessionEvent } from '@wrongstack/core/types';
+/** One transcript line, as `AgentMonitorService` stores it. */
+export interface AgentTranscriptLine {
+    id: string;
+    subagentId: string;
+    agentName: string;
+    ts: string;
+    kind: string;
+    content: string;
+    iteration: number;
+    toolName?: string | undefined;
+    toolOk?: boolean | undefined;
+    costUsd?: number | undefined;
+}
+/** Structural shape of `AgentMonitorService.loadSessionsFromDisk`'s rows. */
+export interface AgentVirtualSessionLike {
+    subagentId: string;
+    agentName?: string | undefined;
+    status?: string | undefined;
+    task?: string | undefined;
+    transcript?: AgentTranscriptLine[] | undefined;
+}
+/** What `session.start` carries for one subagent. */
+export interface AgentSessionPayload {
+    subagentId: string;
+    agentName?: string | undefined;
+    status?: string | undefined;
+    task?: string | undefined;
+    role?: string | undefined;
+    provider?: string | undefined;
+    model?: string | undefined;
+    startedAt?: string | undefined;
+    endedAt?: string | undefined;
+    transcript?: AgentTranscriptLine[] | undefined;
+}
+export type LoadAgentSessions = (subagentIds: readonly string[]) => Promise<AgentVirtualSessionLike[]>;
+/**
+ * Build the `agentSessions` field of a `session.start` payload.
+ *
+ * Returns an empty array — never a partial one — when the journal names no
+ * agents, so a session that never delegated costs nothing.
+ *
+ * The journal's status wins over the monitor's. The monitor reports
+ * `'restored'` for anything it read back from disk, which says only "this
+ * process did not watch it run"; the journal knows whether the agent finished,
+ * failed, or was still going when the file ended.
+ */
+export declare function buildAgentSessionsPayload(events: readonly SessionEvent[] | undefined, load: LoadAgentSessions | undefined): Promise<AgentSessionPayload[]>;
+//# sourceMappingURL=session-agent-sessions.d.ts.map

package/dist/server/session-cleanup-scheduler.d.ts

@@ -2,11 +2,11 @@ import type { Logger } from '@wrongstack/core/types';
 import { type SessionDeletionContext } from './session-deletion.js';
 export declare const DEFAULT_EMPTY_SESSION_CLEANUP_INTERVAL_MS: number;
 export declare const EMPTY_SESSION_CLEANUP_INTERVAL_ENV = "WRONGSTACK_EMPTY_SESSION_CLEANUP_INTERVAL_MS";
-export interface EmptySessionCleanupContext extends SessionDeletionContext {
+interface EmptySessionCleanupContext extends SessionDeletionContext {
     hasParticipants: (sessionId: string) => boolean;
     logger: Pick<Logger, 'info' | 'error'>;
 }
-export interface EmptySessionCleanupResult {
+interface EmptySessionCleanupResult {
     deleted: number;
     errors: number;
 }
@@ -23,4 +23,5 @@ export declare function scheduleOwnerlessEmptySessionCleanup(ctx: EmptySessionCl
     dispose: () => Promise<void>;
     runNow: () => Promise<EmptySessionCleanupResult>;
 };
+export {};
 //# sourceMappingURL=session-cleanup-scheduler.d.ts.map

package/dist/server/session-deletion.d.ts

@@ -1,6 +1,7 @@
 import type { SessionStore } from '@wrongstack/core/types';
 export interface SessionDeletionContext {
     getActiveSessionId: () => string;
+    getActiveSessionIds?: (() => string[]) | undefined;
     getSessionStore: () => SessionStore;
     refreshSessions: () => Promise<void>;
 }

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

@@ -9,13 +9,14 @@
  * as getters/setters so this stays a pure function of its context. Handler
  * bodies are a verbatim lift — only dependency references changed.
  */
-import type { Context } from '@wrongstack/core/agent';
+import type { Agent, Context } from '@wrongstack/core/agent';
 import type { createStrategyCompactor } from '@wrongstack/core/execution';
 import type { EventBus } from '@wrongstack/core/kernel';
 import type { ToolRegistry } from '@wrongstack/core/registry';
 import type { SessionStore, TokenCounter } from '@wrongstack/core/types';
 import type { WebSocket } from 'ws';
 import type { CustomModeStore } from './custom-context-modes.js';
+import type { LoadAgentSessions } from './session-agent-sessions.js';
 import type { SessionRouteHandlers } from './session-routes.js';
 import type { SessionIdentityTarget } from './standalone-session-identity.js';
 import type { ConnectedClient } from './types.js';
@@ -26,6 +27,7 @@ type OutboundMessage = {
 };
 type SessionStartPayload = {
     sessionId: string;
+    startedAt?: string | undefined;
     model: string;
     provider: string;
     maxContext: number;
@@ -38,6 +40,26 @@ type SessionStartPayload = {
     mode: string;
     contextMode: string;
 };
+/**
+ * Every session a connected surface is currently displaying.
+ *
+ * `client.sessionId` alone is the tab the connection last acted on; a WebUI
+ * page holds up to four on one socket and declares them with
+ * `session.subscribe`. Deleting or garbage-collecting a session that a
+ * background tab is showing is the same class of bug as broadcasting to the
+ * wrong tab, so both guards read the declared set.
+ */
+export declare function collectDisplayedSessionIds(ctx: {
+    getSession: () => {
+        id: string;
+    };
+    clients?: {
+        values(): Iterable<{
+            sessionId?: string | null | undefined;
+            sessionIds?: ReadonlySet<string> | undefined;
+        }>;
+    } | undefined;
+}): string[];
 export interface SessionHandlersContext {
     config: {
         provider: string;
@@ -83,8 +105,67 @@ export interface SessionHandlersContext {
     /** When sessionId is provided, abort only that session's run; otherwise abort all. */
     abortActiveRun?: ((sessionId?: string) => void) | undefined;
     isRunActive?: ((sessionId?: string) => boolean) | undefined;
+    hasSession?: ((id: string) => boolean) | undefined;
+    /**
+     * Does this host ALREADY hold an open writer for this session?
+     *
+     * Distinct from `hasSession`, which every multi-session host answers `true`
+     * to (it only says "this runtime can serve that id"). Re-opening the journal
+     * for a session that is already live leaks a second `FileSessionWriter` and
+     * file handle onto the same file, and with four tabs that happens on every
+     * single tab click. Hosts that cannot tell leave it undefined and keep the
+     * old behaviour.
+     */
+    isSessionLive?: ((id: string) => boolean) | undefined;
+    /**
+     * Sessions that just stopped being displayed by ANY connection.
+     *
+     * A closed tab leaves its per-session agent — context, transcript, open
+     * journal writer — behind, and nothing ever asked for it again. The host
+     * uses this to retire them; it must still refuse to retire one whose run is
+     * live, because a background run outlives the tab that started it.
+     */
+    onSessionsUndisplayed?: ((sessionIds: string[]) => void) | undefined;
+    getAgent?: ((sessionId?: string) => Agent) | undefined;
+    /**
+     * Non-creating registry lookup for READ paths. `getAgent` CREATES on read
+     * (and can evict a live tab's agent to make room), so a read such as
+     * `context.debug` resolves through this when the host supplies one. A miss
+     * here must surface as an explicit "not available" answer — never a silent
+     * fallback to the shared root context, which belongs to whichever session
+     * the runtime currently points at.
+     */
+    peekAgent?: ((sessionId?: string) => Agent | undefined) | undefined;
     sessionStartPayload: (overrides?: Record<string, unknown>) => Promise<SessionStartPayload>;
+    systemPrompt?: {
+        applyVariant?: (variant: string) => Promise<void>;
+    } | undefined;
+    /**
+     * Host-owned serialiser shared with `createConversationOperations`. When
+     * omitted the handlers create a private one, which still orders session
+     * transitions against each other but not against run setup.
+     */
+    withSessionTransition?: (<T>(operation: () => Promise<T>) => Promise<T>) | undefined;
+    /**
+     * Read back the transcripts of NAMED subagents (see
+     * `session-agent-sessions.ts`). Hosts that run a fleet supply it; hosts that
+     * do not leave it undefined and their replays simply carry no subagents.
+     */
+    loadAgentSessions?: LoadAgentSessions | undefined;
 }
+/**
+ * Serialiser for operations that re-point a session's runtime context.
+ *
+ * Session transitions (session.new / session.resume) swap writers, contexts
+ * and todo sidecars in several steps. A turn that begins mid-swap would read
+ * a half-applied context, so `user_message` setup runs through the SAME gate
+ * — which is why this is created once per host and shared, rather than being
+ * private to the session handlers.
+ *
+ * Only the SETUP is gated; agent runs proceed outside it so four tabs still
+ * stream concurrently.
+ */
+export declare function createSessionTransitionGate(): <T>(operation: () => Promise<T>) => Promise<T>;
 export declare function createSessionHandlers(ctx: SessionHandlersContext): SessionRouteHandlers;
 export {};
 //# sourceMappingURL=session-handlers.d.ts.map

package/dist/server/session-history.d.ts

@@ -27,19 +27,19 @@ export interface SessionHistoryWireEntry {
     outcome?: SessionSummary['outcome'];
     isCurrent: boolean;
 }
-export interface SessionInspectEvent {
+interface SessionInspectEvent {
     ts: string;
     type: SessionEvent['type'];
     label: string;
     detail: string;
 }
-export interface SessionInspectFileEntry {
+interface SessionInspectFileEntry {
     operation: string;
     filePath: string;
     toolName: string;
     ts: string;
 }
-export interface SessionInspectPayload {
+interface SessionInspectPayload {
     id: string;
     title: string;
     name?: string | undefined;
@@ -70,4 +70,5 @@ export declare function buildInspectPayload(summary: SessionSummary | undefined,
 }): SessionInspectPayload;
 export declare function toSessionHistoryEntry(summary: SessionSummary, currentSessionId: string): SessionHistoryWireEntry;
 export declare function toSessionHistoryEntries(summaries: SessionSummary[], currentSessionId: string): SessionHistoryWireEntry[];
+export {};
 //# sourceMappingURL=session-history.d.ts.map

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

@@ -22,6 +22,8 @@ export interface SessionRouteHandlers {
     inspectSession: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
     listCheckpoints: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
     rewindSession: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
+    /** Declare which sessions this connection is displaying (its open tabs). */
+    subscribeSessions: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
 }
 export declare function handleSessionRoute(ws: WebSocket, msg: WSClientMessage, handlers: SessionRouteHandlers): Promise<boolean>;
 //# sourceMappingURL=session-routes.d.ts.map

package/dist/server/session-scoped-prefs.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The preference keys that belong to a CONVERSATION, not the project.
+ *
+ * A leaf module on purpose: this is a plain constant that both the preference
+ * handlers and the per-tab agent registry need, and importing it from
+ * `prefs-handlers.ts` dragged that module's dependencies (`@wrongstack/tools`
+ * among them) into every consumer's module graph.
+ *
+ * @module session-scoped-prefs
+ */
+/**
+ * Preferences that belong to ONE session rather than to the process.
+ *
+ * Every WebUI tab runs its own session with its own agent context, so these
+ * have to land on the calling tab's meta bag: flipping yolo in tab 3 must not
+ * hand tab 1's run blanket tool approval, and a context strategy chosen for a
+ * long refactor tab must not re-shape a quick question in the tab beside it.
+ *
+ * Everything NOT listed here (locale, ports, HQ, telegram, feature flags,
+ * breaker, proxy, log level…) is genuinely process-wide and keeps its single
+ * global home.
+ *
+ * The browser half is `SESSION_SCOPED_PREFS` in
+ * `webui/src/stores/local-prefs.ts`; the two sets must be identical and
+ * `webui/tests/server/session-scoped-prefs-parity.test.ts` enforces it.
+ */
+export declare const SESSION_SCOPED_PREF_KEYS: ReadonlySet<string>;
+//# sourceMappingURL=session-scoped-prefs.d.ts.map

package/dist/server/setup-events-core-watchers.d.ts

@@ -3,13 +3,18 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { WebSocket } from 'ws';
 import type { ConnectedClient, WSServerMessage } from './types.js';
-export interface SetupEventsCoreWatcherDeps {
+interface SetupEventsCoreWatcherDeps {
     events: EventBus;
-    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;
     clients: Map<WebSocket, ConnectedClient>;
     context: Context;
     wpaths?: WstackPaths | undefined;
 }
 export declare function registerSetupEventsCoreWatchers(deps: SetupEventsCoreWatcherDeps): Array<() => void>;
 export declare function registerSetupEventsClientStatusWriter(deps: SetupEventsCoreWatcherDeps): () => void;
+export {};
 //# sourceMappingURL=setup-events-core-watchers.d.ts.map

package/dist/server/setup-events-fleet-broadcaster.d.ts

@@ -2,14 +2,19 @@ import type { Context } from '@wrongstack/core/agent';
 import type { WstackPaths } from '@wrongstack/core/utils';
 import type { WebSocket } from 'ws';
 import type { ConnectedClient, WSServerMessage } from './types.js';
-export interface SetupEventsFleetBroadcasterDeps {
+interface SetupEventsFleetBroadcasterDeps {
     globalConfigPath?: string | undefined;
     wpaths?: WstackPaths | undefined;
     context: Context;
     clients: Map<WebSocket, ConnectedClient>;
-    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;
     onFleetBroadcaster?: ((fn: () => Promise<void>) => void) | undefined;
     isDisposed: () => boolean;
 }
 export declare function registerSetupEventsFleetBroadcaster(deps: SetupEventsFleetBroadcasterDeps): (() => void) | undefined;
+export {};
 //# sourceMappingURL=setup-events-fleet-broadcaster.d.ts.map

package/dist/server/setup-events-pattern-handlers.d.ts

@@ -3,7 +3,11 @@ import type { WebSocket } from 'ws';
 import type { ConnectedClient, WSServerMessage } from './types.js';
 export declare function registerSetupEventsPatternHandlers(options: {
     events: EventBus;
-    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;
     clients: Map<WebSocket, ConnectedClient>;
     sessionPayload: <T extends Record<string, unknown>>(payload: T) => T;
 }): Array<() => void>;

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

@@ -7,7 +7,7 @@ type SetupEventBroadcast = (clients: Map<WebSocket, ConnectedClient>, msg: WSSer
 type SessionPayload = <T extends Record<string, unknown>>(payload: T) => T & {
     sessionId: string;
 };
-export interface SetupEventsProviderHandlersDeps {
+interface SetupEventsProviderHandlersDeps {
     on: SetupEventOn;
     broadcast: SetupEventBroadcast;
     clients: Map<WebSocket, ConnectedClient>;

package/dist/server/setup-events-session-helpers.d.ts

@@ -1,10 +1,23 @@
 import type { Context } from '@wrongstack/core/agent';
 import type { SessionEventBridge } from '@wrongstack/core/storage';
-export declare function createSetupEventSessionHelpers(context: Context, sessionBridge: SessionEventBridge | undefined): {
+interface SetupEventSessionHelperOptions {
+    /**
+     * Resolve an audit bridge bound to ONE session's writer.
+     *
+     * Without it, audit events can only be appended for the session the runtime
+     * is currently on, and a background tab's tool/error history is dropped —
+     * the tab keeps working, but resuming it later shows a run with no tool
+     * record. Hosts that can address a session's writer (the WebUI, via its
+     * per-session agent registry) pass this so every tab journals its own work.
+     */
+    bridgeForSession?: ((sessionId: string) => SessionEventBridge | undefined) | undefined;
+}
+export declare function createSetupEventSessionHelpers(context: Context, sessionBridge: SessionEventBridge | undefined, options?: SetupEventSessionHelperOptions): {
     currentSessionId: () => string;
     sessionPayload: <T extends Record<string, unknown>>(payload: T) => T & {
         sessionId: string;
     };
     appendForCurrentSession: (sessionId: string | undefined, event: Parameters<SessionEventBridge['append']>[0]) => void;
 };
+export {};
 //# sourceMappingURL=setup-events-session-helpers.d.ts.map

package/dist/server/setup-events-status-watcher.d.ts

@@ -3,13 +3,18 @@ import type { WstackPaths } from '@wrongstack/core/utils';
 import type { WebSocket } from 'ws';
 import { type FileWatcherMetrics } from './setup-events-watcher.js';
 import type { ConnectedClient, WSServerMessage } from './types.js';
-export interface SetupEventsStatusWatcherDeps {
+interface SetupEventsStatusWatcherDeps {
     wpaths?: WstackPaths | undefined;
     watcherMetrics?: FileWatcherMetrics | undefined;
     clients: Map<WebSocket, ConnectedClient>;
-    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;
     on: <E extends EventName>(event: E, listener: Listener<E>) => (() => void) | void;
     isDisposed: () => boolean;
 }
 export declare function registerSetupEventsStatusWatcher(deps: SetupEventsStatusWatcherDeps): (() => void) | undefined;
+export {};
 //# sourceMappingURL=setup-events-status-watcher.d.ts.map

package/dist/server/setup-events-subagent-handlers.d.ts

@@ -5,7 +5,11 @@ import type { SetupEventProjection } from './setup-event-projection.js';
 import type { ConnectedClient, WSServerMessage } from './types.js';
 export declare function registerSetupEventsSubagentHandlers(options: {
     on: <E extends EventName>(event: E, listener: Listener<E>) => void;
-    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;
     clients: Map<WebSocket, ConnectedClient>;
     context: Context;
     projection?: SetupEventProjection | undefined;

package/dist/server/setup-events-tool-handlers.d.ts

@@ -7,12 +7,25 @@ import type { SetupEventProjection } from './setup-event-projection.js';
 import type { ConnectedClient, WSServerMessage } from './types.js';
 export declare function registerSetupEventsToolHandlers(options: {
     on: <E extends EventName>(event: E, listener: Listener<E>) => void;
-    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;
     clients: Map<WebSocket, ConnectedClient>;
     context: Context;
     pendingConfirms: Map<string, PendingConfirm>;
     projection?: SetupEventProjection | undefined;
     sessionPayload: <T extends Record<string, unknown>>(payload: T) => T;
     appendForCurrentSession: (sessionId: string | undefined, event: Parameters<SessionEventBridge['append']>[0]) => void;
+    /**
+     * The Context of a NAMED session, without creating one. The state blocks
+     * below (todos / tasks / plan / side effects) read a session's OWN stores;
+     * the shared root context's stores belong to whichever tab is foreground
+     * right now. Hosts without a per-session registry may omit it — an event
+     * naming an unresolvable session then broadcasts no board at all instead of
+     * mis-paired data.
+     */
+    sessionContext?: ((sessionId: string) => Context | undefined) | undefined;
 }): void;
 //# sourceMappingURL=setup-events-tool-handlers.d.ts.map

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

@@ -10,7 +10,11 @@ import type { ConnectedClient, WSServerMessage } from './types.js';
 export type { FileWatcherMetrics } from './setup-events-watcher.js';
 export interface SetupEventsDeps {
     events: EventBus;
-    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;
     clients: Map<WebSocket, ConnectedClient>;
     config: {
         tools?: {
@@ -28,6 +32,22 @@ export interface SetupEventsDeps {
      * with no tool history.
      */
     sessionBridge?: SessionEventBridge | undefined;
+    /**
+     * Resolve an audit bridge for a NAMED session. Hosts that serve several
+     * sessions at once (the WebUI, four tabs on one runtime) pass this so a
+     * background tab's tool and error history lands in its own journal instead
+     * of being dropped for not being the session in front.
+     */
+    bridgeForSession?: ((sessionId: string) => SessionEventBridge | undefined) | undefined;
+    /**
+     * The Context of a NAMED session, without creating one.
+     *
+     * Event payloads describe the session that produced them, and some of what
+     * they carry is a per-tab setting — the iteration ceiling above all. Reading
+     * it off the shared root context told a background tab it was on "3 / 500"
+     * when its own cap was something else entirely.
+     */
+    sessionContext?: ((sessionId: string) => Context | undefined) | undefined;
     /** Optional wpaths for writing status.json file. */
     wpaths?: WstackPaths | undefined;
     /** Optional live file-watcher metrics sink. */

package/dist/server/setup-screen.d.ts

@@ -14,13 +14,13 @@
 import type { ProviderRegistry } from '@wrongstack/core/registry';
 import type { Provider } from '@wrongstack/core/types';
 import type { Config } from '@wrongstack/core/types';
-export interface ResolveSetupProviderOptions {
+interface ResolveSetupProviderOptions {
     config: Config;
     /** True when neither provider nor model is set in config. */
     needsProvider: boolean;
     providerRegistry: ProviderRegistry;
 }
-export interface ResolvedSetupProvider {
+interface ResolvedSetupProvider {
     provider: Provider;
     /**
      * True when no provider could be resolved and a stub was created — the
@@ -42,4 +42,5 @@ export interface ResolvedSetupProvider {
  * Throws on provider-construction failure (same as the inline code).
  */
 export declare function resolveSetupProvider(opts: ResolveSetupProviderOptions): ResolvedSetupProvider;
+export {};
 //# sourceMappingURL=setup-screen.d.ts.map

package/dist/server/shell-git-routes.d.ts

@@ -4,6 +4,10 @@ export interface ShellGitRouteHandlers {
     gitInfo: (ws: WebSocket) => Promise<void>;
     gitChanges: (ws: WebSocket) => Promise<void>;
     gitDiff: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
+    gitStage?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    gitUnstage?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    gitDiscard?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
+    gitCommit?: ((ws: WebSocket, msg: WSClientMessage) => Promise<void>) | undefined;
     shellOpen: (ws: WebSocket, msg: WSClientMessage) => Promise<void>;
 }
 export declare function handleShellGitRoute(ws: WebSocket, msg: WSClientMessage, handlers: ShellGitRouteHandlers): Promise<boolean>;