@wrongstack/webui 0.313.1 → 0.316.2

package/dist/stores/local-prefs.d.ts

@@ -56,6 +56,44 @@ export interface LocalPrefs {
             parameters?: Record<string, unknown>;
         };
     }>;
+    /**
+     * Deterministic cost tiers. A level binds a fallback profile, a spend budget
+     * and runtime overrides under one name; `routing` maps a role/phase/`*` to a
+     * level; `leader` governs how much authority the leader has over its own tier.
+     */
+    modelTiers: {
+        enabled?: boolean;
+        default?: string;
+        levels?: Record<string, {
+            fallbackProfile?: string;
+            provider?: string;
+            model?: string;
+            maxCostUsd?: number;
+            maxIterations?: number;
+            maxToolCalls?: number;
+            maxTokens?: number;
+            timeoutMs?: number;
+            description?: string;
+            modelRuntime?: {
+                reasoning?: {
+                    mode?: 'auto' | 'on' | 'off';
+                    effort?: string;
+                    preserve?: boolean;
+                };
+                cache?: {
+                    ttl?: '5m' | '1h';
+                };
+            };
+        }>;
+        routing?: Record<string, string>;
+        leader?: {
+            mode?: 'off' | 'propose' | 'auto';
+            dwellTurns?: number;
+            minSavingsUsd?: number;
+            maxContextFillForSwitch?: number;
+            maxTier?: string;
+        };
+    };
     /** Auto-derive a fallback chain from keyed providers when the list is empty. */
     fallbackAuto: boolean;
     /** Recurring provider/model blackout windows for autonomous routing. */
@@ -205,9 +243,58 @@ export interface LocalPrefs {
      * Periodic probe targets `<wrongProxyUrl>/api/health`; 2xx → active.
      */
     wrongProxyUrl: string;
+    /** Master toggle for global keyboard shortcuts. Defaults to false. */
+    keyboardShortcuts: boolean;
+    /**
+     * Per-session overrides for the keys in `SESSION_SCOPED_PREF_KEYS`.
+     *
+     * The flat fields above are the EFFECTIVE view of the tab in front, so
+     * existing readers (`useLocalPrefs((s) => s.autonomy)`) keep working and
+     * automatically describe the right tab. This map is what makes them
+     * per-tab rather than one value the four tabs fight over.
+     */
+    bySession: Record<string, Partial<LocalPrefs>>;
+    /**
+     * What a NEWLY opened tab inherits for the session-scoped keys — the last
+     * value the user chose, mirroring the server, which persists the same keys
+     * to config as the default a new tab starts from.
+     */
+    sessionDefaults: Partial<LocalPrefs>;
+    /** Which session the flat fields currently describe. */
+    activeSessionId: string | null;
     set: (patch: Partial<LocalPrefs>) => void;
+    /** Point the flat fields at a tab, materialising its overrides. */
+    bindSession: (sessionId: string | null) => void;
+    /**
+     * Apply a server-sent patch. `sessionId` names the tab it belongs to; a
+     * patch for a BACKGROUND tab updates that tab's override and leaves the
+     * fields the UI is rendering alone.
+     */
+    applyRemote: (patch: Partial<LocalPrefs>, sessionId?: string | undefined) => void;
+    /** Forget a closed tab's overrides. */
+    forgetSession: (sessionId: string) => void;
     reset: () => void;
 }
+/**
+ * Preferences that belong to ONE session rather than to the browser.
+ *
+ * Must stay in step with `SESSION_SCOPED_PREF_KEYS` on the server
+ * (`webui-server/src/server/prefs-handlers.ts`) — the server already keys
+ * these off the calling tab's context meta, and a client that treats them as
+ * global shows tab 1's autonomy while tab 3 is on screen. Parity is enforced
+ * by `tests/server/session-scoped-prefs-parity.test.ts`, not by memory.
+ */
+export declare const SESSION_SCOPED_PREFS: readonly ["autonomy", "autonomyDelayMs", "autoProceedMaxIterations", "yolo", "maxIterations", "contextStrategy", "contextMode", "contextAutoCompact", "tokenSavingTier", "systemPromptVariant", "reasoningMode", "reasoningEffort", "reasoningPreserve", "nextPrediction", "nextStepsTool"];
+/**
+ * The effective value of a session-scoped preference for ONE session.
+ *
+ * Reading the flat field answers for the tab IN FRONT, which is wrong whenever
+ * the question is about another tab. The dangerous instance was `yolo`: a
+ * background tab's tool-approval prompt was auto-approved because the tab the
+ * user happened to be looking at had YOLO on — approving a tool in a session
+ * the user never put in that mode.
+ */
+export declare function sessionPref<K extends keyof LocalPrefs>(sessionId: string | null | undefined, key: K): LocalPrefs[K];
 export declare const useLocalPrefs: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<LocalPrefs>, "persist" | "setState"> & {
     setState(partial: LocalPrefs | Partial<LocalPrefs> | ((state: LocalPrefs) => LocalPrefs | Partial<LocalPrefs>), replace?: false | undefined): unknown;
     setState(state: LocalPrefs | ((state: LocalPrefs) => LocalPrefs), replace: true): unknown;

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

@@ -1,5 +1,5 @@
 /** Mirrors HQ/HqMailboxMessageScope. Derived server-side, but always revalidated client-side. */
-export type MailboxMessageScope = 'project' | 'session' | 'agent';
+type MailboxMessageScope = 'project' | 'session' | 'agent';
 /**
  * Classify a mailbox recipient address for UI labeling. Mirrors the
  * server-side helper in `@wrongstack/core/hq/mailbox-mapper` so the
@@ -56,7 +56,7 @@ export interface MailboxAgent {
     /** Number of tool calls the agent has made in the current iteration. */
     toolCalls?: number;
 }
-export interface MailboxCompactionResult {
+interface MailboxCompactionResult {
     readByAllRemoved: number;
     expiredRemoved: number;
     stalePurged: number;

package/dist/stores/memory-injector-store.d.ts

@@ -49,7 +49,7 @@ export interface MemoryContextSnapshot {
     exitedMemoryIds: string[];
     sessionId?: string | undefined;
 }
-export interface ContextMemoryRecord extends MemoryInjectorTraceMemory {
+interface ContextMemoryRecord extends MemoryInjectorTraceMemory {
     state: 'injected' | 'active' | 'exited';
     trigger: string;
     enteredAt: string;
@@ -76,6 +76,6 @@ interface MemoryInjectorTraceState {
 }
 /** UI preview budget; full text lives in SAGE SQLite, not the browser store. */
 export declare const MAX_MEMORY_DETAIL_TEXT_CHARS = 300;
-export declare const useMemoryInjectorTraceStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MemoryInjectorTraceState>>;
+export declare const useMemoryInjectorTraceStore: import("./session-scoped-store").SessionScopedStore<MemoryInjectorTraceState>;
 export {};
 //# sourceMappingURL=memory-injector-store.d.ts.map

package/dist/stores/memory-lifecycle-store.d.ts

@@ -1,5 +1,5 @@
 export type MemoryLifecycleAction = 'entered' | 'updated' | 'merged' | 'recovered' | 'exited' | 'related' | 'superseded' | 'archived' | 'staled' | 'contradicted';
-export interface MemoryLifecycleItem {
+interface MemoryLifecycleItem {
     id: string;
     at: string;
     event: string;
@@ -18,6 +18,10 @@ interface MemoryLifecycleState {
 export declare function toMemoryLifecycleItem(payload: Record<string, unknown> & {
     event: string;
 }, now?: Date): MemoryLifecycleItem | null;
-export declare const useMemoryLifecycleStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MemoryLifecycleState>>;
+/**
+ * SAGE lifecycle events belong to the conversation whose run produced them,
+ * so each tab keeps its own trace.
+ */
+export declare const useMemoryLifecycleStore: import("./session-scoped-store").SessionScopedStore<MemoryLifecycleState>;
 export {};
 //# sourceMappingURL=memory-lifecycle-store.d.ts.map

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

@@ -89,7 +89,7 @@ export interface LiveAgentActivity {
     linesRemoved: number;
 }
 /** Project-wide totals summed across every live session's agents. */
-export interface FleetAggregate {
+interface FleetAggregate {
     toolCalls: number;
     costUsd: number;
     tokensIn: number;
@@ -141,7 +141,7 @@ export interface CurrentSessionStats {
     costUsd?: number;
     timestamp?: number;
 }
-export interface MonitorState {
+interface MonitorState {
     /** Connected client counts by type */
     clientCounts: ClientCounts;
     /** Recent mail queue activity (last 50 events) */
@@ -174,4 +174,5 @@ export interface MonitorState {
     clear: () => void;
 }
 export declare const useMonitorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MonitorState>>;
+export {};
 //# sourceMappingURL=monitor-store.d.ts.map

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

@@ -0,0 +1,141 @@
+export type NotificationVariant = 'success' | 'error' | 'warn' | 'info';
+export type ToastVariant = NotificationVariant;
+export interface NotificationAction {
+    label: string;
+    onClick: () => void;
+}
+export type ToastAction = NotificationAction;
+export interface AppNotification {
+    id: string;
+    message: string;
+    variant: NotificationVariant;
+    timestamp: number;
+    read: boolean;
+    ttl?: number | undefined;
+    action?: NotificationAction | undefined;
+}
+export interface ToastEntry {
+    id: string;
+    message: string;
+    variant: NotificationVariant;
+    ttl: number;
+    action?: NotificationAction | undefined;
+}
+export declare const MAX_NOTIFICATIONS = 100;
+export declare const ACTION_TTL_MS = 8000;
+export interface NotificationStoreState {
+    /** All recorded notifications in history, newest first */
+    notifications: AppNotification[];
+    /** Ephemeral toasts currently rendered on screen */
+    toasts: ToastEntry[];
+    /** Push a new toast + notification */
+    push: (entry: {
+        message: string;
+        variant: NotificationVariant;
+        ttl?: number | undefined;
+        action?: NotificationAction | undefined;
+    }) => string;
+    /** Dismiss active ephemeral toast from screen */
+    dismissToast: (id: string) => void;
+    /** Mark a single notification as read */
+    markAsRead: (id: string) => void;
+    /** Mark all notifications as read */
+    markAllAsRead: () => void;
+    /** Remove a notification from history */
+    removeNotification: (id: string) => void;
+    /** Clear all notification history */
+    clearAll: () => void;
+}
+export declare const useNotificationStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<NotificationStoreState>, "persist" | "setState"> & {
+    setState(partial: NotificationStoreState | Partial<NotificationStoreState> | ((state: NotificationStoreState) => NotificationStoreState | Partial<NotificationStoreState>), replace?: false | undefined): unknown;
+    setState(state: NotificationStoreState | ((state: NotificationStoreState) => NotificationStoreState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            notifications: {
+                id: string;
+                message: string;
+                variant: NotificationVariant;
+                timestamp: number;
+                read: boolean;
+                ttl?: number | undefined;
+                action?: {
+                    label: string;
+                    onClick: () => void;
+                } | undefined;
+            }[];
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: NotificationStoreState) => void) => () => void;
+        onFinishHydration: (fn: (state: NotificationStoreState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            notifications: {
+                id: string;
+                message: string;
+                variant: NotificationVariant;
+                timestamp: number;
+                read: boolean;
+                ttl?: number | undefined;
+                action?: {
+                    label: string;
+                    onClick: () => void;
+                } | undefined;
+            }[];
+        }, unknown>>;
+    };
+}>;
+/** Imperative API. Pass plain strings or arrays of strings for multi-line. */
+export declare const toast: {
+    success: (msg: string, ttl?: number) => string;
+    error: (msg: string, ttl?: number) => string;
+    warn: (msg: string, ttl?: number) => string;
+    info: (msg: string, ttl?: number) => string;
+    /**
+     * Fire a toast carrying an "Undo" action button. The toast lingers
+     * for {@link ACTION_TTL_MS} so the user has time to react; letting it
+     * expire is the same as not undoing.
+     */
+    undoable: (msg: string, onUndo: () => void, label?: string, ttl?: number) => string;
+    dismiss: (id: string) => void;
+};
+export declare const useToastStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<NotificationStoreState>, "persist" | "setState"> & {
+    setState(partial: NotificationStoreState | Partial<NotificationStoreState> | ((state: NotificationStoreState) => NotificationStoreState | Partial<NotificationStoreState>), replace?: false | undefined): unknown;
+    setState(state: NotificationStoreState | ((state: NotificationStoreState) => NotificationStoreState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            notifications: {
+                id: string;
+                message: string;
+                variant: NotificationVariant;
+                timestamp: number;
+                read: boolean;
+                ttl?: number | undefined;
+                action?: {
+                    label: string;
+                    onClick: () => void;
+                } | undefined;
+            }[];
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: NotificationStoreState) => void) => () => void;
+        onFinishHydration: (fn: (state: NotificationStoreState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            notifications: {
+                id: string;
+                message: string;
+                variant: NotificationVariant;
+                timestamp: number;
+                read: boolean;
+                ttl?: number | undefined;
+                action?: {
+                    label: string;
+                    onClick: () => void;
+                } | undefined;
+            }[];
+        }, unknown>>;
+    };
+}>;
+//# sourceMappingURL=notification-store.d.ts.map

package/dist/stores/provider-status-store.d.ts

@@ -40,8 +40,26 @@ export interface ProviderHealthEntry {
     lastAgentId?: string | undefined;
     lastFailureAt?: number | null | undefined;
 }
+export interface ProviderAuditEntry {
+    ts: number;
+    providerId: string;
+    model: string;
+    from: ProviderHealthState;
+    to: ProviderHealthState;
+    reason: string;
+    expiresAt: number | null;
+    error: {
+        kind: string;
+        status: number | null;
+        message: string;
+        sessionId: string | null;
+        agentId: string | null;
+    } | null;
+}
 interface ProviderStatusStore {
     entries: Record<string, ProviderHealthEntry>;
+    /** Durable block/open audit trail tail (newest first), fed by provider.audit.get. */
+    audit: ProviderAuditEntry[];
     /** Summary counts from the last full snapshot (or null before first fetch). */
     summary: {
         totalPairs: number;
@@ -56,6 +74,7 @@ interface ProviderStatusStore {
     update: (entry: ProviderHealthEntry) => void;
     hydrate: (entries: ProviderHealthEntry[]) => void;
     applySnapshot: (snapshot: Record<string, unknown>) => void;
+    setAudit: (lines: ProviderAuditEntry[]) => void;
     setLoading: (loading: boolean) => void;
     setError: (error: string | null) => void;
     clear: () => void;

package/dist/stores/restore-tabs-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Tabs the boot reconciliation set aside for the user to decide about.
+ *
+ * The tab strip lives in `localStorage`, so it outlives the process that made
+ * it. Restoring it blindly meant a fresh `wstack --webui` came up wearing the
+ * previous run's tabs and paid for a full journal resume — todo board included
+ * — before the user had typed anything. Dropping it silently is the other
+ * extreme: work the user meant to come back to disappears without a word.
+ *
+ * So neither. A WebUI that starts fresh IS fresh — one new session, one tab —
+ * and the sessions that were in the strip are OFFERED. Resuming is then what it
+ * should always have been: an explicit act, on named sessions, that the user
+ * chose.
+ *
+ * The offer holds ids only. Titles come from `useHistoryStore`, which fills in
+ * from the `sessions.list` frame that arrives moments later; the modal renders
+ * with ids until it does rather than blocking on it.
+ */
+interface RestoreTabsState {
+    /** Stale slots awaiting an answer. Empty means no offer is pending. */
+    candidates: string[];
+    /** Present the offer. A second offer replaces the first (boot happens once). */
+    offer: (sessionIds: readonly string[]) => void;
+    /** Dismiss without restoring anything. */
+    dismiss: () => void;
+}
+export declare const useRestoreTabsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<RestoreTabsState>>;
+export {};
+//# sourceMappingURL=restore-tabs-store.d.ts.map

package/dist/stores/resume-progress-store.d.ts

@@ -0,0 +1,58 @@
+/**
+ * resume-progress-store.ts — which tabs are waiting for a transcript.
+ *
+ * A resume is not instant. The server has to replay the session's whole JSONL
+ * journal before it can answer, and a journal that has grown to a hundred-odd
+ * megabytes takes seconds on an idle machine and tens of seconds on one that
+ * is also running agents. Until this store existed the surface said nothing
+ * about that: the tab appeared immediately (the client opens the slot before
+ * asking), the lane was empty, and an empty lane renders the welcome screen —
+ * so a resume in progress was pixel-identical to a session with no messages in
+ * it. The honest reading of that screen is "the transcript is gone", which is
+ * what it was reported as.
+ *
+ * Deliberately NOT part of the chat lane. Lanes are persisted to localStorage,
+ * and a "waiting" flag must not survive the reload that ended the wait — a
+ * page that came back with a stale flag would spin forever. This is in-memory,
+ * per-session, and every exit is covered: the `session.start` that answers,
+ * the error frame that refuses, and a wall-clock ceiling for the answer that
+ * never comes at all.
+ */
+/**
+ * Upper bound on a single wait, after which the tab stops claiming to be
+ * loading and falls back to whatever the lane holds.
+ *
+ * Generous on purpose: the point of the ceiling is that a dropped frame cannot
+ * strand the pane forever, not to guess how long a resume "should" take.
+ * Cutting a genuinely slow resume short would put the welcome screen back
+ * under a user who is about to be handed their transcript.
+ */
+export declare const RESUME_PROGRESS_TIMEOUT_MS: number;
+export interface ResumeProgressDetail {
+    stage: string;
+    loadedBytes: number;
+    totalBytes: number;
+    updatedAt: number;
+}
+interface ResumeProgressState {
+    /** sessionId -> ms epoch the resume request went out. */
+    startedAt: Record<string, number>;
+    /** sessionId -> latest server-reported journal load progress. */
+    progress: Record<string, ResumeProgressDetail>;
+    /** A resume request for this session is on the wire. */
+    begin: (sessionId: string) => void;
+    /** Update the visible progress for an in-flight resume. */
+    update: (sessionId: string, progress: Omit<ResumeProgressDetail, 'updatedAt'>) => void;
+    /** Its answer (or refusal) arrived. Safe to call for sessions never begun. */
+    end: (sessionId: string) => void;
+    /** Socket-level reset: nothing outstanding can still be answered. */
+    clear: () => void;
+}
+export declare const useResumeProgressStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ResumeProgressState>>;
+export declare function resumeStageLabel(stage: string | undefined): string;
+export declare function resumeProgressPercent(progress: ResumeProgressDetail | undefined): number | null;
+export declare function formatResumeBytes(bytes: number): string;
+/** Selector-friendly read: is this tab still waiting for its transcript? */
+export declare function isResuming(sessionId: string | null | undefined): boolean;
+export {};
+//# sourceMappingURL=resume-progress-store.d.ts.map

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

@@ -10,7 +10,7 @@ interface InspectFileEntry {
     toolName: string;
     ts: string;
 }
-export interface SessionInspectData {
+interface SessionInspectData {
     id: string;
     title: string;
     name?: string | undefined;