@wrongstack/webui 0.313.0 → 0.316.1

package/dist/stores/session-lanes.d.ts

@@ -0,0 +1,242 @@
+/**
+ * session-lanes.ts — Per-tab session accounting.
+ *
+ * Twin of `chat-lanes.ts` for everything that is true of ONE session rather
+ * than of the project: which model it runs, how many tokens it burned, what it
+ * costs, which iteration it is on, its todo list, its context ceiling.
+ *
+ * The split matters. Before this file all of it lived in one store describing
+ * "the session in front", and a background run's `provider.response` either
+ * landed on the foreground tab's counters (visible bleed: tab 1's cost jumping
+ * while tab 2 worked) or was folded into a side-map of parked snapshots by
+ * hand, one call site at a time. Now a lane owns its numbers whether or not it
+ * is on screen, and the foreground is a pointer.
+ *
+ * Fields that describe the PROJECT — its root, cwd, name, the catalog of modes,
+ * the app version — stay global here: four tabs of the same project share them
+ * and giving each lane a copy would only invent ways for them to disagree.
+ */
+import type { Usage } from '@wrongstack/core/types';
+import type { SessionInfo } from './types.js';
+export type CacheStats = {
+    readTokens: number;
+    writeTokens: number;
+    hitRatio: number;
+    providers?: Array<{
+        provider: string;
+        input: number;
+        cacheRead: number;
+        cacheWrite: number;
+        hitRatio: number;
+    }>;
+    coverageTokens: number;
+};
+export type ContextLimitWarning = {
+    previousMaxContext: number;
+    maxContext: number;
+    providerId: string;
+    modelId: string;
+};
+export type TodoItem = {
+    id: string;
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    activeForm?: string | undefined;
+    blockedBy?: string[] | undefined;
+    kanbanBoardId?: string | undefined;
+    kanbanTaskId?: string | undefined;
+};
+/** Everything true of ONE session. */
+export interface SessionLaneData {
+    session: SessionInfo | null;
+    totalTokens: Usage;
+    lastInputTokens: number;
+    cost: number;
+    startTime: number | null;
+    maxContext: number;
+    contextLimitWarning: ContextLimitWarning | null;
+    cacheStats: CacheStats | null;
+    inputCost: number;
+    outputCost: number;
+    cacheReadCost: number;
+    reasoningEffortLevels?: string[] | undefined;
+    /**
+     * Tri-state effort-support signal from the model's reasoningConfig
+     * (`undefined` = undocumented → show the control with the full canonical
+     * set; `false` = model documents NO effort control → hide it). Never
+     * boolean-coerce: undefined is not false.
+     */
+    effortSupported?: boolean | undefined;
+    /** Project-wide effort — display-only hint behind the composer auto option. */
+    projectReasoningEffort?: string | undefined;
+    mode: string;
+    contextMode: string;
+    iteration: {
+        index: number;
+        max: number;
+    } | null;
+    todos: TodoItem[];
+    droppedTools: number;
+    lastVisitedAt: number;
+}
+export declare function createSessionLaneData(): SessionLaneData;
+/** Stable empty lane. Singleton for the same referential-stability reason as
+ *  `chat-lanes.EMPTY_LANE`. */
+export declare const EMPTY_SESSION_LANE: SessionLaneData;
+/** Project-wide state. Four tabs of one project share exactly this much. */
+export interface SessionGlobals {
+    projectName: string;
+    projectRoot: string;
+    cwd: string;
+    modes: Array<{
+        id: string;
+        name: string;
+        description: string;
+    }>;
+    contextModes: Array<{
+        id: string;
+        name: string;
+        description: string;
+        thresholds?: {
+            warn: number | undefined;
+            soft: number;
+            hard: number;
+        };
+        preserveK?: number | undefined;
+        eliseThreshold?: number | undefined;
+        custom?: boolean | undefined;
+    }>;
+    appVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+}
+interface SessionLanesState extends SessionGlobals {
+    lanes: Record<string, SessionLaneData>;
+    activeSessionId: string;
+}
+export declare const SESSION_DEFAULT_LANE_ID = "__unbound__";
+export declare const useSessionLanes: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SessionLanesState>, "persist" | "setState"> & {
+    setState(partial: Partial<SessionLanesState> | SessionLanesState | ((state: SessionLanesState) => Partial<SessionLanesState> | SessionLanesState), replace?: false | undefined): unknown;
+    setState(state: SessionLanesState | ((state: SessionLanesState) => SessionLanesState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SessionLanesState, {
+            projectName: string;
+            projectRoot: string;
+            cwd: string;
+            lanes: {
+                [k: string]: {
+                    session: SessionInfo | null;
+                    mode: string;
+                    contextMode: string;
+                    lastInputTokens: number;
+                    lastVisitedAt: number;
+                };
+            };
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SessionLanesState) => void) => () => void;
+        onFinishHydration: (fn: (state: SessionLanesState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SessionLanesState, {
+            projectName: string;
+            projectRoot: string;
+            cwd: string;
+            lanes: {
+                [k: string]: {
+                    session: SessionInfo | null;
+                    mode: string;
+                    contextMode: string;
+                    lastInputTokens: number;
+                    lastVisitedAt: number;
+                };
+            };
+        }, unknown>>;
+    };
+}>;
+export declare function readSessionLane(sessionId: string | null | undefined): SessionLaneData;
+export declare function hasSessionLane(sessionId: string | null | undefined): boolean;
+export declare function sessionLaneIds(): string[];
+export declare function ensureSessionLane(sessionId: string): string;
+export declare function disposeSessionLane(sessionId: string): void;
+/**
+ * Retire the pre-session lane once a real session exists.
+ *
+ * Nothing is carried over: accounting recorded before any session started
+ * (a stray todo list, a zeroed token counter) describes no session, and
+ * inheriting it would credit the new tab with numbers it never earned. The
+ * CHAT lane is different — a message typed before `session.start` landed is
+ * the user's, and `adoptDefaultLane` does move that.
+ */
+export declare function adoptDefaultSessionLane(sessionId: string): void;
+/**
+ * Move the foreground pointer — BOTH of them.
+ *
+ * The chat surface and the accounting surface each keep their own
+ * `activeSessionId`, and "the tab in front" is only meaningful when the two
+ * agree. Every caller used to move them in a pair by hand, which made a
+ * missed line a silent bleed: the strip highlighted one slot while the
+ * transcript rendered another's, and the send path stamped a third. Moving the
+ * chat pointer from here makes the pair impossible to half-apply.
+ *
+ * `chat-lanes` must NOT reach back into this module (it is the lower layer),
+ * so this direction is the only one available — and it is the right one:
+ * accounting is what the tab registry re-points.
+ */
+export declare function setActiveSessionLane(sessionId: string | null): void;
+export declare function activeSessionLaneId(): string;
+/**
+ * Hook form of the lane pointer, `null` before any session is bound.
+ *
+ * Components that need "which tab is the user looking at" must read THIS and
+ * not `useSessionStore((s) => s.session?.id)`. The latter is the foreground
+ * lane's SessionInfo record, which is null between opening a tab and its
+ * `session.start` landing — a window in which the tab strip concluded no tab
+ * was in front and purged the slot the user had just opened.
+ */
+export declare function useActiveSessionId(): string | null;
+export interface SessionLaneActions {
+    readonly sessionId: string;
+    readonly data: SessionLaneData;
+    setSession: (session: SessionInfo | null) => void;
+    startSession: (session: SessionInfo) => void;
+    endSession: () => void;
+    updateUsage: (usage: Usage, providerId?: string) => void;
+    addCost: (cost: number) => void;
+    setEnvRates: (env: {
+        maxContext?: number | undefined;
+        mode?: string | undefined;
+        contextMode?: string | undefined;
+        inputCost?: number | undefined;
+        outputCost?: number | undefined;
+        cacheReadCost?: number | undefined;
+        reasoningEffortLevels?: string[] | undefined;
+        hasReasoningEffortKey?: boolean;
+        effortSupported?: boolean | undefined;
+        hasEffortSupportedKey?: boolean;
+        projectReasoningEffort?: string | undefined;
+        hasProjectEffortKey?: boolean;
+    }) => void;
+    setIteration: (it: {
+        index: number;
+        max: number;
+    } | null) => void;
+    setContextUsage: (tokens: number, maxContext?: number | undefined) => void;
+    setContextLimitWarning: (w: ContextLimitWarning | null) => void;
+    setCacheStats: (c: CacheStats | null) => void;
+    setTodos: (todos: TodoItem[]) => void;
+    setDroppedTools: (count: number) => void;
+    touch: () => void;
+    patch: (updates: Partial<SessionLaneData>) => void;
+}
+/**
+ * The one way to write session accounting. Same contract as `chatLane`: the
+ * session must be named, so a background run can never credit its tokens to
+ * the tab in front.
+ */
+export declare function sessionLane(sessionId: string): SessionLaneActions;
+export declare function activeSessionLane(): SessionLaneActions;
+/** Project-wide setters. Deliberately not per-lane. */
+export declare function setSessionGlobals(patch: Partial<SessionGlobals>): void;
+export {};
+//# sourceMappingURL=session-lanes.d.ts.map

package/dist/stores/session-scoped-store.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A store whose ENTIRE state belongs to one conversation.
+ *
+ * The WebUI runs up to four conversations side by side. Most stores describe
+ * one of them — the memory injector's traces, the Brain council's panels, the
+ * side effects a run recorded — and holding them in a single global object
+ * meant the four tabs shared one copy. Two failure modes, and the codebase has
+ * had both:
+ *
+ *   - the handler wrote whatever arrived, so a background tab's records landed
+ *     on the screen the user was looking at; or
+ *   - the handler defended itself with `isActiveSessionMessage` and DROPPED
+ *     the background tab's records entirely, so switching to that tab showed
+ *     an empty panel for work that had definitely happened.
+ *
+ * Neither is "separate". This factory gives every conversation its own store
+ * instance, with the reducer written exactly as it would be for a single
+ * session — no `bySession` threading through the reducer bodies, no chance of
+ * a new action forgetting the key.
+ *
+ * Shape, deliberately mirroring the chat/session lane facades:
+ *   - calling it as a hook, or reaching for `getState()`, addresses the tab
+ *     that is IN FRONT — the right default for components and for a user
+ *     action, which by definition happens in the visible tab;
+ *   - `for(sessionId)` addresses one named conversation, which is what a WS
+ *     handler must use: the frame names its session and the write has to land
+ *     there whether or not that tab is on screen.
+ *
+ * Bounds: one instance per live conversation, dropped when the tab closes
+ * (`onLaneDisposed`). The cap is a backstop for ids that never see a lane
+ * teardown — losing a diagnostic buffer for a conversation nobody is showing
+ * costs nothing, and the next event rebuilds it.
+ *
+ * @module session-scoped-store
+ */
+import { type StateCreator, type StoreApi } from 'zustand/vanilla';
+export interface SessionScopedStore<S> {
+    /** Hook form: the state of the tab in front. */
+    <T>(selector: (state: S) => T): T;
+    /** Snapshot of the tab in front. */
+    getState(): S;
+    /** Patch the tab in front. */
+    setState(partial: Partial<S> | ((state: S) => Partial<S>)): void;
+    /** Subscribe to the tab in front. Resolved once, at call time. */
+    subscribe(listener: (state: S, previous: S) => void): () => void;
+    /** The store of ONE named conversation — the handler entry point. */
+    for(sessionId: string | null | undefined): StoreApi<S>;
+    /** Forget a conversation's copy. Called on lane teardown. */
+    dropSession(sessionId: string): void;
+    /** Conversations holding an instance, oldest first. */
+    sessionIds(): string[];
+}
+export declare function createSessionScopedStore<S>(initializer: StateCreator<S, [], []>, options?: {
+    max?: number;
+}): SessionScopedStore<S>;
+//# sourceMappingURL=session-scoped-store.d.ts.map

package/dist/stores/session-store.d.ts

@@ -1,120 +1,22 @@
+/**
+ * session-store.ts — Foreground view over the session lane registry.
+ *
+ * The per-tab accounting lives in `session-lanes.ts`. This module projects
+ * `lanes[activeSessionId]` (plus the project-wide globals) behind the
+ * historical `useSessionStore` API, so every panel that renders the tab in
+ * front keeps working unchanged.
+ *
+ * WS handlers must NOT write through this facade — they route by
+ * `payload.sessionId` via `sessionFor(msg)` / `sessionLane(sessionId)`.
+ * Writing here from a handler credits a background run's tokens, cost or
+ * iteration to whichever tab happens to be on screen.
+ */
 import type { Usage } from '@wrongstack/core/types';
+import { type CacheStats, type ContextLimitWarning, createSessionLaneData, type SessionGlobals, type SessionLaneData, type TodoItem, useSessionLanes } from './session-lanes.js';
 import type { SessionInfo } from './types.js';
-interface SessionState {
-    session: SessionInfo | null;
-    totalTokens: Usage;
-    /** Input tokens of the LAST provider response — used as the "live context
-     *  size" indicator in the topbar (matches what TUI's ContextChip shows). */
-    lastInputTokens: number;
-    cost: number;
-    startTime: number | null;
-    /** Active effective context window. 0 = unknown. */
-    maxContext: number;
-    /** Live provider-reported decrease, shown until the session/model changes. */
-    contextLimitWarning: {
-        previousMaxContext: number;
-        maxContext: number;
-        providerId: string;
-        modelId: string;
-    } | null;
-    /**
-     * Live prompt-cache snapshot from the most recent `stats.get`
-     * reply. `null` until the first reply lands — distinguishes "no
-     * cache yet" from "0 hit". Cleared on session start/end and on
-     * provider/model switch (same lifecycle as `contextLimitWarning`,
-     * so a stale reading from the previous session can never leak into
-     * the new one).
-     */
-    cacheStats: {
-        readTokens: number;
-        writeTokens: number;
-        hitRatio: number;
-        /** Session cache telemetry split by routed provider (fallback/model switches included). */
-        providers?: Array<{
-            provider: string;
-            input: number;
-            cacheRead: number;
-            cacheWrite: number;
-            hitRatio: number;
-        }>;
-        /**
-         * Cached prefix of the most recent prompt, capped at `lastInputTokens`
-         * so the coverage figure never overshoots the live request size.
-         * Used by the context breakdown modal and topbar cache badge.
-         */
-        coverageTokens: number;
-    } | null;
-    /** USD per 1M tokens — used to compute cost deltas on every provider.response. */
-    inputCost: number;
-    outputCost: number;
-    cacheReadCost: number;
-    /** Effort levels the ACTIVE model advertises (session.start payload).
-     *  Undefined when the model has no explicit list — the settings effort
-     *  dropdown then shows the full canonical set. Same lifecycle as
-     *  `cacheStats`: refreshed on every session.start (which fires on model
-     *  switch), so a stale list from the previous model never leaks. */
-    reasoningEffortLevels?: string[] | undefined;
-    /** basename(projectRoot) for the topbar. */
-    projectName: string;
-    /** Full project root path — used for richer tooltips / hover context. */
-    projectRoot: string;
-    /** Full working directory path — can differ from projectRoot. */
-    cwd: string;
-    /** Active mode id (default | code | …). */
-    mode: string;
-    /** All modes the backend knows about, populated by modes.list. The
-     *  topbar mode chip uses this to render a picker; empty until the
-     *  backend responds. */
-    modes: Array<{
-        id: string;
-        name: string;
-        description: string;
-    }>;
-    /** Active context-window policy id (balanced | frugal | deep | archival). */
-    contextMode: string;
-    /** Context-window policy presets from the backend. */
-    contextModes: Array<{
-        id: string;
-        name: string;
-        description: string;
-        thresholds?: {
-            warn: number | undefined;
-            soft: number;
-            hard: number;
-        };
-        preserveK?: number | undefined;
-        eliseThreshold?: number | undefined;
-        custom?: boolean | undefined;
-    }>;
-    /** Iteration progress while the agent is running. Resets on run.result. */
-    iteration: {
-        index: number;
-        max: number;
-    } | null;
-    /** Live snapshot of context.todos — backend broadcasts on every
-     *  tool.executed, and the sidebar/overlay reads from here. */
-    todos: Array<{
-        id: string;
-        content: string;
-        status: 'pending' | 'in_progress' | 'completed';
-        activeForm?: string | undefined;
-        /** Board-derived titles of the unfinished work this row waits on. */
-        blockedBy?: string[] | undefined;
-        kanbanBoardId?: string | undefined;
-        kanbanTaskId?: string | undefined;
-    }>;
-    /** Client-side wall-clock at the last successful session.start. Survives
-     *  F5 because it's in partialize. Used by the resilience verifier view
-     *  to confirm the active session round-trips through localStorage. */
-    lastVisitedAt: number;
-    /** Current app version string (e.g. "0.7.0") from the boot-time update check. */
-    appVersion: string;
-    /** Latest published version on npm, when known. */
-    latestVersion: string;
-    /** True when a newer published version exists than appVersion. */
-    updateAvailable: boolean;
-    /** Number of tools dropped from provider requests due to maxTools limit (0 = no limit or within limit). */
-    droppedTools: number;
+export type { CacheStats, ContextLimitWarning, SessionLaneData, TodoItem, } from './session-lanes.js';
+export { activeSessionLane, activeSessionLaneId, adoptDefaultSessionLane, disposeSessionLane, ensureSessionLane, hasSessionLane, readSessionLane, type SessionLaneActions, sessionLane, sessionLaneIds, setActiveSessionLane, setSessionGlobals, useSessionLanes, } from './session-lanes.js';
+export interface SessionState extends SessionGlobals, SessionLaneData {
     setSession: (session: SessionInfo | null) => void;
     updateUsage: (usage: Usage, providerId?: string) => void;
     addCost: (cost: number) => void;
@@ -131,56 +33,97 @@ interface SessionState {
         outputCost?: number | undefined;
         cacheReadCost?: number | undefined;
         reasoningEffortLevels?: string[] | undefined;
+        /** Tri-state: undefined=undocumented, false=model documents no effort control. */
+        effortSupported?: boolean | undefined;
+        /** Project-wide effort — display-only hint behind the composer auto option. */
+        projectReasoningEffort?: string | undefined;
     }) => void;
     setIteration: (it: {
         index: number;
         max: number;
     } | null) => void;
     setContextUsage: (tokens: number, maxContext?: number | undefined) => void;
-    setContextLimitWarning: (warning: SessionState['contextLimitWarning']) => void;
-    setCacheStats: (cache: SessionState['cacheStats']) => void;
-    setModes: (modes: Array<{
-        id: string;
-        name: string;
-        description: string;
-    }>) => void;
-    setContextModes: (modes: SessionState['contextModes']) => void;
-    setTodos: (todos: SessionState['todos']) => void;
+    setContextLimitWarning: (warning: ContextLimitWarning | null) => void;
+    setCacheStats: (cache: CacheStats | null) => void;
+    setModes: (modes: SessionGlobals['modes']) => void;
+    setContextModes: (modes: SessionGlobals['contextModes']) => void;
+    setTodos: (todos: TodoItem[]) => void;
     setUpdateInfo: (info: {
         appVersion: string;
         latestVersion: string;
         updateAvailable: boolean;
     }) => void;
     setDroppedTools: (count: number) => void;
+    switchSession: (newSessionId: string) => void;
+}
+/**
+ * Re-point the stores that ROUTE SERVER WRITES by bound session.
+ *
+ * `useFileStore` and `useGitChangesStore` both compare the `sessionId` a
+ * server message carries against their own bound id, and a write whose stamp
+ * does not match is parked in `…BySession[<that session>]` rather than applied
+ * to the projection panels render. So a pointer move that skips these does not
+ * merely show stale data — it makes every stamped response for the tab now in
+ * front invisible. `files.tree` and `files.read` are the case users see: the
+ * explorer keeps the previous tab's tree and double-clicking a file opens
+ * nothing, because both responses are stamped with the LANE POINTER
+ * (`withSession` -> `foregroundSessionId()`) while `fileSessionId` still names
+ * the tab before the switch.
+ *
+ * Deliberately narrower than `bindForeground`: this is the data half, safe to
+ * call from any path that moves the pointer. Chrome (which view is up, whether
+ * the sidebar is open) is navigation, not routing, and is rebound only where
+ * the surface really is switching tabs.
+ *
+ * Both binds are idempotent -- each returns early when already on `sessionId`
+ * -- so calling this from more than one pointer-move path is free.
+ */
+export declare function bindForegroundStores(sessionId: string | null): void;
+declare function getState(): SessionState;
+declare function setState(partial: Partial<SessionState> | ((state: SessionState) => Partial<SessionState>)): void;
+declare function subscribe(listener: (state: SessionState, prev: SessionState) => void): () => void;
+interface SessionStoreFacade {
+    <T>(selector: (state: SessionState) => T): T;
+    getState: typeof getState;
+    getInitialState: typeof getState;
+    setState: typeof setState;
+    subscribe: typeof subscribe;
+    /** The lane registry's own persist API (rehydrate/flush/clearStorage). */
+    persist: (typeof useSessionLanes)['persist'];
+}
+export declare const useSessionStore: SessionStoreFacade;
+interface SessionSnapshot {
+    session: SessionInfo | null;
+    provider?: string | undefined;
+    model?: string | undefined;
+    mode: string;
+    contextMode: string;
+    totalTokens: Usage;
+    lastInputTokens: number;
+    cost: number;
+    startTime: number | null;
+    maxContext: number;
+    reasoningEffortLevels?: string[] | undefined;
+    cacheStats: CacheStats | null;
+    iteration: {
+        index: number;
+        max: number;
+    } | null;
+    todos: TodoItem[];
 }
-export declare const useSessionStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SessionState>, "persist" | "setState"> & {
-    setState(partial: Partial<SessionState> | SessionState | ((state: SessionState) => Partial<SessionState> | SessionState), replace?: false | undefined): unknown;
-    setState(state: SessionState | ((state: SessionState) => SessionState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SessionState, {
-            session: SessionInfo | null;
-            projectName: string;
-            projectRoot: string;
-            cwd: string;
-            mode: string;
-            contextMode: string;
-            lastVisitedAt: number;
-        }, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: SessionState) => void) => () => void;
-        onFinishHydration: (fn: (state: SessionState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SessionState, {
-            session: SessionInfo | null;
-            projectName: string;
-            projectRoot: string;
-            cwd: string;
-            mode: string;
-            contextMode: string;
-            lastVisitedAt: number;
-        }, unknown>>;
-    };
-}>;
-export {};
+/**
+ * Read-through view of the lane registry in the shape the old parked-snapshot
+ * map exposed. Kept so the few call sites that want "what does tab X look
+ * like right now" keep reading — but it is no longer a separate copy of the
+ * truth that has to be kept in sync, which is what let a tab come back showing
+ * a neighbour's model or zeroed counters.
+ */
+export declare const memorySessionSnapshots: {
+    has(sessionId: string): boolean;
+    get(sessionId: string): SessionSnapshot | undefined;
+    set(sessionId: string, snapshot: Partial<SessionSnapshot>): void;
+    delete(sessionId: string): void;
+    clear(): void;
+};
+export { createSessionLaneData };
 //# sourceMappingURL=session-store.d.ts.map