@wrongstack/webui 1.0.24 → 1.0.26

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

@@ -1,5 +1,7 @@
 export type NotificationVariant = 'success' | 'error' | 'warn' | 'info';
+export type NotificationFilter = 'important' | 'all' | NotificationVariant;
 export type ToastVariant = NotificationVariant;
+export declare function matchesNotificationFilter(notification: Pick<AppNotification, 'variant'>, filter: NotificationFilter): boolean;
 export interface NotificationAction {
     label: string;
     onClick: () => void;
@@ -28,6 +30,9 @@ export interface NotificationStoreState {
     notifications: AppNotification[];
     /** Ephemeral toasts currently rendered on screen */
     toasts: ToastEntry[];
+    /** Shared by desktop and mobile notification menus. */
+    filter: NotificationFilter;
+    setFilter: (filter: NotificationFilter) => void;
     /** Push a new toast + notification */
     push: (entry: {
         message: string;
@@ -51,6 +56,7 @@ export declare const useNotificationStore: import("zustand").UseBoundStore<Omit<
     setState(state: NotificationStoreState | ((state: NotificationStoreState) => NotificationStoreState), replace: true): unknown;
     persist: {
         setOptions: (options: Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            filter: NotificationFilter;
             notifications: {
                 id: string;
                 message: string;
@@ -70,6 +76,7 @@ export declare const useNotificationStore: import("zustand").UseBoundStore<Omit<
         onHydrate: (fn: (state: NotificationStoreState) => void) => () => void;
         onFinishHydration: (fn: (state: NotificationStoreState) => void) => () => void;
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            filter: NotificationFilter;
             notifications: {
                 id: string;
                 message: string;
@@ -104,6 +111,7 @@ export declare const useToastStore: import("zustand").UseBoundStore<Omit<import(
     setState(state: NotificationStoreState | ((state: NotificationStoreState) => NotificationStoreState), replace: true): unknown;
     persist: {
         setOptions: (options: Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            filter: NotificationFilter;
             notifications: {
                 id: string;
                 message: string;
@@ -123,6 +131,7 @@ export declare const useToastStore: import("zustand").UseBoundStore<Omit<import(
         onHydrate: (fn: (state: NotificationStoreState) => void) => () => void;
         onFinishHydration: (fn: (state: NotificationStoreState) => void) => () => void;
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<NotificationStoreState, {
+            filter: NotificationFilter;
             notifications: {
                 id: string;
                 message: string;

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

@@ -0,0 +1,54 @@
+/**
+ * A line comment left on the working-tree diff in the Changes view. Comments
+ * are project-scoped (`scope` = project root): the diff is the repository's,
+ * not a chat session's, so switching tabs keeps them and switching projects
+ * hides them.
+ */
+export interface ReviewComment {
+    id: string;
+    scope: string;
+    /** Repo-relative path, as the Changes panel lists it. */
+    path: string;
+    /** `new` for added/context lines, `old` for removed lines. */
+    side: 'old' | 'new';
+    /** 1-based line number on `side`. */
+    line: number;
+    /** The line's text when the comment was written — quoted in the review. */
+    lineText: string;
+    body: string;
+    createdAt: number;
+}
+interface ReviewState {
+    comments: ReviewComment[];
+    add: (comment: Omit<ReviewComment, 'id' | 'createdAt'>) => ReviewComment | null;
+    update: (id: string, body: string) => void;
+    remove: (id: string) => void;
+    /** Drop every comment in `scope` (after the review went to the composer). */
+    clearScope: (scope: string) => void;
+}
+export declare const useReviewStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ReviewState>, "persist" | "setState"> & {
+    setState(partial: Partial<ReviewState> | ReviewState | ((state: ReviewState) => Partial<ReviewState> | ReviewState), replace?: false | undefined): unknown;
+    setState(state: ReviewState | ((state: ReviewState) => ReviewState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ReviewState, {
+            comments: ReviewComment[];
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ReviewState) => void) => () => void;
+        onFinishHydration: (fn: (state: ReviewState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ReviewState, {
+            comments: ReviewComment[];
+        }, unknown>>;
+    };
+}>;
+/** Comments in `scope`, ordered by file then line — the order the review reads in. */
+export declare function scopedComments(comments: readonly ReviewComment[], scope: string): ReviewComment[];
+/**
+ * The review as one message the agent can act on: each comment names its file
+ * and line, quotes the line it was written against, then the comment.
+ */
+export declare function formatReviewMessage(comments: readonly ReviewComment[]): string;
+export {};
+//# sourceMappingURL=review-store.d.ts.map

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

@@ -0,0 +1,33 @@
+/** A tab is "busy" when its own run is live or it owns a running subagent. */
+export declare function isTabBusy(sessionId: string): boolean;
+/** Everything a busy-tab warning needs to say about one session, gathered in
+ *  one place. The close dialog and the switch-away toast render the same
+ *  `lines`, so the two warnings cannot drift apart or go vague. */
+export interface SessionActivityReport {
+    sessionId: string;
+    isBusy: boolean;
+    /** True when the tab holds nothing at all — no chat history, no agents
+     *  (running or finished), no queued messages, no live run. Such a tab has
+     *  nothing to lose and may close without asking. */
+    isEmpty: boolean;
+    leaderRunning: boolean;
+    runningAgents: Array<{
+        id: string;
+        name: string;
+        brief: string;
+    }>;
+    finishedAgents: number;
+    queuedMessages: number;
+    /** Pre-localized, factual inventory lines (no framing). */
+    lines: string[];
+}
+/** Complete inventory of what a session has in flight: its own run, every
+ *  running subagent with a task preview, finished agents on record, queued
+ *  messages. Reads the lane registries directly, like `isTabBusy`. */
+export declare function describeSessionActivity(sessionId: string): SessionActivityReport;
+/** Thorough, non-blocking notice fired when the foreground moves OFF a busy
+ *  tab: the tab keeps running in its slot, and the user sees exactly what
+ *  stays behind. Switching back is always one click, so this must inform,
+ *  not block. */
+export declare function notifyBusyTabLeftBehind(sessionId: string): void;
+//# sourceMappingURL=session-activity.d.ts.map

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

@@ -1,22 +1,4 @@
-/**
- * session-tab-store.ts — The four slots, and the only place a tab is opened,
- * switched or closed.
- *
- * The model, stated plainly:
- *
- *   - There are exactly FOUR slots. Never more, never a fifth "just for now".
- *   - A slot holds AT MOST one session, and a session sits in AT MOST one slot.
- *     Both directions are enforced here; nothing else is allowed to bind them.
- *   - Switching slots moves a pointer. It does not park, copy, restore or clear
- *     anything, because every slot's state already lives in its own lane
- *     (`chat-lanes.ts`, `session-lanes.ts`) whether or not it is on screen.
- *   - Closing a slot disposes that lane. A closed tab keeps nothing alive.
- *
- * Think of the four slots as four layouts side by side. What makes them
- * side-by-side rather than one surface with four costumes is that no slot can
- * name another slot's state: the lane registries are keyed by session id and
- * every writer must name the session it is writing to.
- */
+export { describeSessionActivity, isTabBusy } from './session-activity.js';
 import { chatLane } from './chat-lanes';
 export declare const MAX_OPEN_TABS = 4;
 export declare const TAB_STORAGE_KEY = "wrongstack.open_session_tabs";
@@ -78,33 +60,6 @@ interface SessionTabState {
     markSeen: (sessionId: string) => void;
     setAttention: (sessionId: string, needsAttention: boolean) => void;
 }
-/** A tab is "busy" when its own run is live or it owns a running subagent. */
-export declare function isTabBusy(sessionId: string): boolean;
-/** Everything a busy-tab warning needs to say about one session, gathered in
- *  one place. The close dialog and the switch-away toast render the same
- *  `lines`, so the two warnings cannot drift apart or go vague. */
-interface SessionActivityReport {
-    sessionId: string;
-    isBusy: boolean;
-    /** True when the tab holds nothing at all — no chat history, no agents
-     *  (running or finished), no queued messages, no live run. Such a tab has
-     *  nothing to lose and may close without asking. */
-    isEmpty: boolean;
-    leaderRunning: boolean;
-    runningAgents: Array<{
-        id: string;
-        name: string;
-        brief: string;
-    }>;
-    finishedAgents: number;
-    queuedMessages: number;
-    /** Pre-localized, factual inventory lines (no framing). */
-    lines: string[];
-}
-/** Complete inventory of what a session has in flight: its own run, every
- *  running subagent with a task preview, finished agents on record, queued
- *  messages. Reads the lane registries directly, like `isTabBusy`. */
-export declare function describeSessionActivity(sessionId: string): SessionActivityReport;
 /**
  * Everything one slot owns, freed in one place.
  *

package/dist/stores/terminal-strip-store.d.ts

@@ -0,0 +1,26 @@
+/** Lines kept for the strip's peek. */
+export declare const TERMINAL_PEEK_LINES = 12;
+export interface TerminalSummary {
+    id: string;
+    name: string;
+    status: 'starting' | 'running' | 'exited';
+    exitCode?: number | undefined;
+    lastOutputAt: number;
+    tail: string[];
+}
+interface TerminalStripState {
+    terminals: TerminalSummary[];
+    /** A terminal the strip asked the dock to bring to the front. */
+    focusRequest: {
+        id: string;
+        nonce: number;
+    } | null;
+    syncTabs(tabs: ReadonlyArray<Pick<TerminalSummary, 'id' | 'name' | 'status' | 'exitCode'>>): void;
+    appendOutput(id: string, lines: string[], at: number): void;
+    requestFocus(id: string): void;
+    clear(): void;
+}
+export declare const useTerminalStripStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TerminalStripState>>;
+export declare function noteTerminalOutput(id: string, data: string): void;
+export {};
+//# sourceMappingURL=terminal-strip-store.d.ts.map

package/dist/stores/ui-store-chrome.d.ts

@@ -1,4 +1,4 @@
-import type { UIState, SessionChromeState } from "./ui-store-types.js";
+import type { SessionChromeState, UIState } from './ui-store-types.js';
 export declare function isDesktopShellStorageContext(): boolean;
 export declare function homeNavigationStatePatch(options?: {
     sidebarOpen?: boolean | undefined;

package/dist/stores/ui-store-persist.d.ts

@@ -1,4 +1,4 @@
-import type { PersistOptions } from "zustand/middleware";
-import type { UIState } from "./ui-store-types.js";
+import type { PersistOptions } from 'zustand/middleware';
+import type { UIState } from './ui-store-types.js';
 export declare const uiPersistOptions: PersistOptions<UIState, Partial<UIState>>;
 //# sourceMappingURL=ui-store-persist.d.ts.map

package/dist/stores/ui-store-types.d.ts

@@ -26,7 +26,7 @@ export type View = (typeof VIEWS)[number];
  *  when reading from localStorage so a stale value (e.g. 'context', a view
  *  removed in v3) lands on 'chat' rather than crashing the router. */
 export declare function coerceView(value: unknown): View;
-export declare const DOCK_SECTIONS: readonly ['goal', 'goal-state', 'fleet', 'work', 'worktrees', 'collab'];
+export declare const DOCK_SECTIONS: readonly ['goal', 'goal-state', 'fleet', 'work', 'worktrees', 'collab', 'browser'];
 export declare function coerceDockSection(value: unknown): DockSection | null;
 export declare const SETTINGS_TABS: readonly ['general', 'fonts', 'provider', 'jev', 'connection', 'agent', 'execution', 'fallbacks', 'routing', 'fleet', 'integrations', 'chimera', 'context', 'logs', 'security', 'display'];
 export declare function coerceSettingsTab(value: unknown): string;
@@ -34,8 +34,8 @@ export declare function coerceSettingsTab(value: unknown): string;
 export declare const SIDEBAR_MIN_WIDTH = 240;
 export declare const SIDEBAR_MAX_WIDTH = 560;
 export declare const SIDEBAR_DEFAULT_WIDTH = 304;
-/** Sections of the WorkspaceDock strip above the chat transcript. */
-export type DockSection = 'goal' | 'goal-state' | 'fleet' | 'work' | 'worktrees' | 'collab';
+/** Sections of the WorkspaceDock in the Session side panel. */
+export type DockSection = 'goal' | 'goal-state' | 'fleet' | 'work' | 'worktrees' | 'collab' | 'browser';
 export type WorkDashboardTab = 'todos' | 'tasks' | 'plan';
 /**
  * User-customized ActivityBar icon order (panels + views). Null = default

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

@@ -1,8 +1,8 @@
-export type { Activity, View, DockSection, WorkDashboardTab, InspectorTab, InspectorTarget, SessionChromeState, UIState, } from "./ui-store-types.js";
-export { ACTIVITIES, coerceActivity, VIEWS, coerceView, DOCK_SECTIONS, coerceDockSection, SETTINGS_TABS, coerceSettingsTab, SIDEBAR_MIN_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_DEFAULT_WIDTH, } from "./ui-store-types.js";
-export { isDesktopShellStorageContext, homeNavigationStatePatch, defaultSkillsState, defaultSessionChrome, readSessionChrome, parkChrome, } from "./ui-store-chrome.js";
-export { uiPersistOptions } from "./ui-store-persist.js";
-import type { UIState } from "./ui-store-types.js";
+export { ACTIVITIES, DOCK_SECTIONS, SETTINGS_TABS, SIDEBAR_DEFAULT_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_MIN_WIDTH, VIEWS, coerceActivity, coerceDockSection, coerceSettingsTab, coerceView, } from './ui-store-types.js';
+export type { Activity, DockSection, InspectorTab, InspectorTarget, SessionChromeState, UIState, View, WorkDashboardTab, } from './ui-store-types.js';
+export { defaultSessionChrome, defaultSkillsState, homeNavigationStatePatch, isDesktopShellStorageContext, parkChrome, readSessionChrome, } from './ui-store-chrome.js';
+export { uiPersistOptions } from './ui-store-persist.js';
+import type { UIState } from './ui-store-types.js';
 export declare const useUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<UIState>, "persist" | "setState"> & {
     setState(partial: Partial<UIState> | UIState | ((state: UIState) => Partial<UIState> | UIState), replace?: false | undefined): unknown;
     setState(state: UIState | ((state: UIState) => UIState), replace: true): unknown;

package/dist/types/brain.d.ts

@@ -65,14 +65,16 @@ interface BrainHeuristicsPatchWire {
 }
 /** Effective single-LLM tier quality gate. */
 interface BrainLlmWire {
-    maxTokens: number;
+    /** Absent = the model's own output ceiling. */
+    maxTokens?: number | undefined;
     rejectUncertain: boolean;
     minConfidence: number;
     denyIsTerminal: 'never' | 'when-decided' | 'always';
 }
 /** Writable single-LLM tier quality gate. */
 interface BrainLlmPatchWire {
-    maxTokens?: number | undefined;
+    /** `null` clears the cap back to the model's own ceiling. */
+    maxTokens?: number | null | undefined;
     rejectUncertain?: boolean | undefined;
     minConfidence?: number | undefined;
     denyIsTerminal?: 'never' | 'when-decided' | 'always' | undefined;

package/dist/types/client-message.d.ts

@@ -1,6 +1,7 @@
 import type { BrainConfigPatchWire } from './brain.js';
 import type { ChronicleFacet, ChronicleMetricsView, ChronicleQuery } from './chronicle.js';
 import type { WSCollabAnnotate, WSCollabGrantControl, WSCollabInjectTool, WSCollabJoin, WSCollabLeave, WSCollabRequestPause, WSCollabResolve, WSCollabResume } from './collab.js';
+import type { WSPromptQueueClientMessage } from './prompt-queue.js';
 import type { SessionScopedPayload, WSUserMessage } from './protocol-core.js';
 import type { ContextEditorMessage, ContextEditorRemoval, WSModelSwitch, WSToolConfirmResult, WSUserInputSubmit } from './runtime.js';
 import type { SageAnchor, SageScope, SageStatus, WSMemorySageForFileRequest } from './sage.js';
@@ -25,7 +26,12 @@ export interface ProviderCustomModelWire {
      */
     modelsDev?: Record<string, unknown> | undefined;
 }
-export type WSClientMessageCore = WSUserMessage | {
+export type WSClientMessageCore = WSUserMessage | WSPromptQueueClientMessage
+/** The user is typing; open the provider connection (`session.provider-warm`). */
+ | {
+    type: 'composer.warm';
+    payload: SessionScopedPayload;
+} | {
     type: 'topic.advice';
     payload: SessionScopedPayload & {
         requestId: string;
@@ -100,7 +106,9 @@ export type WSClientMessageCore = WSUserMessage | {
     payload: Record<string, never>;
 } | {
     type: 'goal.resume';
-    payload: Record<string, never>;
+    payload: {
+        graphId?: string | undefined;
+    };
 } | {
     type: 'goal.stop';
     payload: Record<string, never>;
@@ -113,9 +121,6 @@ export type WSClientMessageCore = WSUserMessage | {
 } | {
     type: 'goal.status';
     payload?: Record<string, never>;
-} | {
-    type: 'goal.state';
-    payload?: Record<string, never>;
 } | {
     type: 'goal.save';
     payload?: Record<string, never>;
@@ -125,12 +130,9 @@ export type WSClientMessageCore = WSUserMessage | {
 } | {
     type: 'goal.load';
     payload: {
-        graphId: string;
-    };
-} | {
-    type: 'goal.toggleAutonomous';
-    payload: {
-        autonomous?: boolean | undefined;
+        graphId?: string | undefined;
+        query?: string | undefined;
+        resume?: boolean | undefined;
     };
 } | {
     type: 'goal.selectPhase';
@@ -444,6 +446,13 @@ export type WSClientMessageCore = WSUserMessage | {
          * what a live lane already has.
          */
         replayFor?: string[];
+        /**
+         * Reconnect catch-up: the last numbered frame (`seq`) this page applied
+         * per tab, valid for the server process that issued `eventEpoch`. The
+         * server sends back the frames after it, then `session.frames_resumed`.
+         */
+        cursors?: Record<string, number>;
+        eventEpoch?: string;
     } & SessionScopedPayload;
 } | {
     type: 'context.clear';
@@ -939,6 +948,11 @@ export type WSClientMessageCore = WSUserMessage | {
     payload: {
         filePath: string;
     } & SessionScopedPayload;
+} | {
+    type: 'files.image';
+    payload: {
+        filePath: string;
+    } & SessionScopedPayload;
 } | {
     type: 'files.skeleton';
     payload: {
@@ -1022,6 +1036,23 @@ export type WSClientMessageCore = WSUserMessage | {
 } | {
     type: 'process.list';
     payload?: SessionScopedPayload;
+} | {
+    type: 'process.output';
+    payload: {
+        pid: number;
+        lines?: number;
+    } & SessionScopedPayload;
+} | {
+    type: 'browser.live.list';
+    payload?: SessionScopedPayload;
+} | {
+    type: 'browser.live.watch';
+    payload: {
+        id: string;
+    } & SessionScopedPayload;
+} | {
+    type: 'browser.live.unwatch';
+    payload?: SessionScopedPayload;
 } | {
     type: 'process.kill';
     payload: {
@@ -1086,6 +1117,23 @@ export type WSClientMessageCore = WSUserMessage | {
     type: 'goal.get';
 } | {
     type: 'goal-state.get';
+} | {
+    type: 'goal-state.set';
+    payload: {
+        goal: string;
+    } & SessionScopedPayload;
+} | {
+    type: 'goal-state.refine';
+    payload?: SessionScopedPayload;
+} | {
+    type: 'goal-state.pause';
+    payload?: Record<string, never>;
+} | {
+    type: 'goal-state.resume';
+    payload?: Record<string, never>;
+} | {
+    type: 'goal-state.clear';
+    payload?: Record<string, never>;
 } | {
     type: 'autonomy.switch';
     payload: {
@@ -1100,6 +1148,49 @@ export type WSClientMessageCore = WSUserMessage | {
 } | {
     type: 'system_prompt.get';
     payload?: SessionScopedPayload;
+} | {
+    type: 'system_prompt.presets.get';
+    payload?: SessionScopedPayload;
+} | {
+    type: 'system_prompt.presets.create';
+    payload: {
+        name: string;
+        baseVariant: 'lite' | 'default' | 'pro';
+    };
+} | {
+    type: 'system_prompt.presets.save';
+    payload: {
+        id: string;
+        revision: number;
+        name: string;
+        text: string;
+        reviewedCurrentSource?: boolean;
+    };
+} | {
+    type: 'system_prompt.presets.activate';
+    payload: {
+        baseVariant: 'lite' | 'default' | 'pro';
+        id?: string;
+        sessionId?: string;
+        scope: 'profile' | 'project';
+    };
+} | {
+    type: 'system_prompt.presets.delete';
+    payload: {
+        id: string;
+    };
+} | {
+    type: 'system_prompt.presets.validate';
+    payload: {
+        text: string;
+    };
+} | {
+    type: 'system_prompt.presets.preview';
+    payload: {
+        text: string;
+        sessionId?: string;
+        requestId: number;
+    };
 } | {
     type: 'projects.list';
 } | {
@@ -1392,6 +1483,23 @@ export type WSClientMessageCore = WSUserMessage | {
         prompt: string;
         arguments?: Record<string, string>;
     };
+} | {
+    type: 'mcp.auth.status';
+    payload: {
+        name: string;
+    };
+} | {
+    type: 'mcp.auth.login';
+    payload: {
+        name: string;
+        clientId?: string;
+        scopes?: string[];
+    };
+} | {
+    type: 'mcp.auth.logout';
+    payload: {
+        name: string;
+    };
 } | {
     type: 'terminal.create';
     payload: {

package/dist/types/prompt-queue.d.ts

@@ -0,0 +1,55 @@
+import type { SessionScopedPayload, WSUserMessageImage } from './protocol-core.js';
+/**
+ * The host-owned prompt queue (`session.prompt-queue` capability): prompts
+ * queued for a session live on the server, which runs them one after another
+ * as the session's turns end — whether or not this page is still open.
+ */
+/** One queued prompt as the server lists it (image bytes stay on the server). */
+export interface WSQueuedPromptView {
+    id: string;
+    text: string;
+    addedAt: number;
+    imageCount: number;
+}
+export type WSPromptQueueClientMessage = {
+    type: 'queue.add';
+    payload: SessionScopedPayload & {
+        text: string;
+        images?: WSUserMessageImage[] | undefined;
+    };
+} | {
+    type: 'queue.remove';
+    payload: SessionScopedPayload & {
+        id: string;
+    };
+} | {
+    type: 'queue.clear';
+    payload?: SessionScopedPayload;
+} | {
+    type: 'queue.get';
+    payload?: SessionScopedPayload;
+};
+/** The session's whole queue, after every change. */
+export interface WSQueueState {
+    type: 'queue.state';
+    payload: SessionScopedPayload & {
+        items: WSQueuedPromptView[];
+    };
+}
+/** A queued prompt just started its turn: render it as the user's message. */
+export interface WSQueueDrained {
+    type: 'queue.drained';
+    payload: SessionScopedPayload & {
+        item: {
+            id: string;
+            text: string;
+            addedAt: number;
+            images?: Array<{
+                data: string;
+                mediaType?: string | undefined;
+                name?: string | undefined;
+            }>;
+        };
+    };
+}
+//# sourceMappingURL=prompt-queue.d.ts.map