@wrongstack/webui 1.0.24 → 1.0.27

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/provider-quota-store.d.ts

@@ -24,6 +24,11 @@ export interface QuotaWindow {
     windowMinutes?: number | undefined;
     /** Absolute reset time in epoch **seconds**. */
     resetsAt?: number | undefined;
+    /**
+     * When the last hour's pace fills the window (epoch **seconds**). Set by the
+     * server only when that lands before `resetsAt`.
+     */
+    exhaustsAt?: number | undefined;
 }
 export interface QuotaCredits {
     hasCredits: boolean;

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/techstack-store.d.ts

@@ -1,6 +1,12 @@
 export type TechStackCoverage = 'full' | 'partial' | 'unsupported';
 export type TechStackJobKind = 'inventory' | 'analyze';
 export type TechStackJobStatus = 'idle' | 'queued' | 'discovering' | 'inventorying' | 'enriching' | 'researching' | 'synthesizing' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Pipeline depth the user picked for the next `analyze` run.
+ * Mirrors `AnalyzeDepth` on the engine; defaults to `'full'` for parity with
+ * the pre-feature one-click Analyze button.
+ */
+export type TechStackAnalyzeDepth = 'inventory' | 'enrich' | 'full';
 export interface TechStackEvidence {
     readonly kind: string;
     readonly source: string;
@@ -62,6 +68,96 @@ export interface TechStackFinding {
     readonly breakingRisk?: string | undefined;
     readonly evidence: readonly TechStackEvidence[];
 }
+/**
+ * One item in a remediation upgrade plan.
+ *
+ * Mirrors `UpgradePlanItem` server-side (`packages/techstack/src/remediation.ts`).
+ * `executable` is true when the engine can drive the change through the
+ * permission-gated `language_package` tool — false for ecosystems that need
+ * a manual command (ruby, dart, maven, gradle, swift, elixir, c/cpp). The UI
+ * uses this to render an "Apply" button vs. a "Copy command" card.
+ */
+export interface TechStackUpgradePlanItem {
+    readonly dependencyName: string;
+    readonly ecosystem: string;
+    readonly workspaceId: string;
+    readonly currentVersion?: string | undefined;
+    readonly targetVersion?: string | undefined;
+    readonly action: TechStackFindingAction;
+    readonly severity: TechStackFindingSeverity;
+    readonly rationale: string;
+    readonly breakingRisk?: string | undefined;
+    readonly suggestedCommand?: string | undefined;
+    readonly executable: boolean;
+}
+export interface TechStackUpgradePlan {
+    readonly snapshotId: string;
+    readonly generatedAt: string;
+    readonly warning: string;
+    readonly summary: {
+        readonly total: number;
+        readonly patch: number;
+        readonly minor: number;
+        readonly major: number;
+        readonly replace: number;
+        readonly remove: number;
+        readonly investigate: number;
+    };
+    readonly items: readonly TechStackUpgradePlanItem[];
+}
+export interface TechStackApplyPlanResult {
+    readonly dryRun: boolean;
+    readonly items: ReadonlyArray<{
+        readonly dependencyName: string;
+        readonly status: 'planned' | 'skipped' | 'applied' | 'failed';
+        readonly detail?: string | undefined;
+    }>;
+}
+/**
+ * Single point on the cross-snapshot trend curve.
+ *
+ * Server-side: `TrendReport` in `packages/techstack/src/trend.ts`. The full
+ * report is heavier than what the page needs day-to-day, so the WebUI view
+ * uses the lightweight shape surfaced by `GET /api/techstack/trends`.
+ */
+export interface TechStackTrendPoint {
+    readonly snapshotId: string;
+    readonly createdAt: string;
+    readonly dependencies: number;
+    readonly outdated: number;
+    readonly vulnerable: number;
+}
+export interface TechStackTrendReport {
+    readonly snapshots: number;
+    readonly vulnerabilityHalfLifeMs?: number | undefined;
+    readonly points: readonly TechStackTrendPoint[];
+    readonly dependencies: ReadonlyArray<{
+        readonly key: string;
+        readonly name: string;
+        readonly ecosystem: string;
+        readonly currentVersion?: string | undefined;
+        readonly lockedVersionAgeMs: number;
+        readonly versionChanges: number;
+    }>;
+}
+/**
+ * Lightweight description of the LLM available for AI-assisted runs.
+ * Mirrors the `GET /api/techstack/models` response. When `available` is false
+ * the model picker is disabled — there is no point letting the user pick a
+ * model when none can answer.
+ */
+export interface TechStackModelInfo {
+    readonly available: boolean;
+    readonly provider: string | null;
+    readonly model: string | null;
+    readonly candidates: ReadonlyArray<{
+        readonly id: string;
+    }>;
+    readonly capabilities: {
+        readonly structuredOutput: boolean;
+        readonly jsonMode: boolean;
+    };
+}
 export interface TechStackSnapshot {
     readonly id: string;
     readonly projectId: string;
@@ -85,6 +181,10 @@ export interface TechStackJobView {
     readonly status: TechStackJobStatus;
     readonly progress: TechStackProgress | null;
     readonly error: string | null;
+    /** Pipeline depth the job will run / is running. */
+    readonly depth?: TechStackAnalyzeDepth;
+    /** Model id the user picked for the LLM research stage. */
+    readonly model?: string;
 }
 interface TechStackState {
     snapshot: TechStackSnapshot | null;
@@ -94,15 +194,54 @@ interface TechStackState {
     activeJob: TechStackJobView | null;
     lastWorkspaceId: string | null;
     reportId: string | null;
+    /** Next analyze options. Persisted in-memory so a refresh keeps them. */
+    selectedDepth: TechStackAnalyzeDepth;
+    selectedModel: string | null;
+    /** `null` until the user opens the TechStack page (the page lazy-loads the list). */
+    availableModels: TechStackModelInfo | null;
+    /** Plan from `GET /api/techstack/remediation`. `null` when not yet fetched. */
+    remediationPlan: TechStackUpgradePlan | null;
+    remediationPreview: TechStackApplyPlanResult | null;
+    remediationLoading: boolean;
+    remediationError: string | null;
+    /** Cross-snapshot trend report. `null` when not yet fetched. */
+    trend: TechStackTrendReport | null;
+    trendLoading: boolean;
+    trendError: string | null;
+    /** Streaming deep-dive partials, keyed by dependency id. */
+    deepDivePartial: {
+        dependencyId: string;
+        status: 'researching';
+        completed: number;
+        total: number;
+    } | null;
     setSnapshot: (snapshot: TechStackSnapshot | null, stale?: boolean) => void;
     setLoading: (loading: boolean) => void;
     setError: (error: string | null) => void;
-    jobStarted: (jobId: string, kind: TechStackJobKind) => void;
+    jobStarted: (jobId: string, kind: TechStackJobKind, options?: {
+        depth?: TechStackAnalyzeDepth;
+        model?: string;
+    }) => void;
     jobProgress: (jobId: string, progress: TechStackProgress) => void;
     jobFailed: (jobId: string, error: string) => void;
     jobCancelled: (jobId: string) => void;
     workspaceCompleted: (workspaceId: string) => void;
     reportReady: (reportId: string) => void;
+    setSelectedDepth: (depth: TechStackAnalyzeDepth) => void;
+    setSelectedModel: (model: string | null) => void;
+    setAvailableModels: (models: TechStackModelInfo) => void;
+    setRemediation: (plan: TechStackUpgradePlan, preview: TechStackApplyPlanResult) => void;
+    setRemediationLoading: (loading: boolean) => void;
+    setRemediationError: (error: string | null) => void;
+    setTrend: (trend: TechStackTrendReport) => void;
+    setTrendLoading: (loading: boolean) => void;
+    setTrendError: (error: string | null) => void;
+    setDeepDivePartial: (partial: {
+        dependencyId: string;
+        status: 'researching';
+        completed: number;
+        total: number;
+    } | null) => void;
     clear: () => void;
 }
 export declare const useTechStackStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TechStackState>>;

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/types.d.ts

@@ -95,6 +95,11 @@ export interface ChatMessage {
      *  most recent start and would leave earlier ones stuck on "Running...". */
     toolUseId?: string | undefined;
     isError?: boolean | undefined;
+    /** Set on the error bubble of a run a provider killed on a retryable
+     *  failure (overload, dropped connection, 5xx): the one error the Continue
+     *  countdown may auto-fire for, in `auto` autonomy. Every other error —
+     *  loop guard, iteration limit, auth, bad request — keeps a manual button. */
+    autoContinue?: boolean | undefined;
     timestamp: number;
     usage?: Usage | undefined;
     streaming?: boolean | undefined;

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;