@wrongstack/tui 1.0.29 → 1.0.32

package/dist/app-action-workflows.d.ts

@@ -0,0 +1,215 @@
+import type { AutonomyStage } from '@wrongstack/core/types';
+import type { SddBoardSnapshot } from '@wrongstack/sdd';
+import type { State } from './app-state.js';
+import type { GoalSummary } from './app-state-core-types.js';
+import type { FleetEntry } from './app-state-fleet.js';
+import type { AutonomyOption, ShadowState, WorktreeRow } from './ui-contracts.js';
+export type AppActionWorkflows = {
+    type: 'autonomyPickerOpen';
+    options: AutonomyOption[];
+} | {
+    type: 'autonomyPickerClose';
+} | {
+    type: 'autonomyPickerMove';
+    delta: number;
+} | {
+    type: 'autonomyPickerHint';
+    text?: string | undefined;
+} | {
+    type: 'shadowOpen';
+    shadow: ShadowState;
+} | {
+    type: 'shadowClose';
+} | {
+    type: 'shadowUpdate';
+    shadow: ShadowState;
+} | {
+    type: 'shadowHint';
+    text?: string | undefined;
+} | {
+    type: 'bugHuntContinueOpen';
+    info: NonNullable<State['bugHuntContinue']>;
+} | {
+    type: 'bugHuntContinueClose';
+} | {
+    type: 'bugHuntRunningOpen';
+    info: NonNullable<State['bugHuntRunning']>;
+} | {
+    type: 'bugHuntRunningClose';
+} | {
+    type: 'fleetSeed';
+    entries: FleetEntry[];
+    cost: number;
+} | {
+    type: 'fleetSpawn';
+    id: string;
+    name?: string | undefined;
+    provider?: string | undefined;
+    model?: string | undefined;
+    transcriptPath?: string | undefined;
+} | {
+    type: 'fleetStart';
+    id: string;
+    taskId?: string | undefined;
+} | {
+    type: 'fleetDelta';
+    id: string;
+    text: string;
+} | {
+    type: 'fleetMessage';
+    id: string;
+    text: string;
+} | {
+    type: 'fleetTool';
+    id: string;
+    name?: string | undefined;
+    ok?: boolean | undefined;
+    durationMs?: number | undefined;
+    outputBytes?: number | undefined;
+    outputLines?: number | undefined;
+} | {
+    type: 'fleetToolStart';
+    id: string;
+    name: string;
+} | {
+    type: 'fleetToolEnd';
+    id: string;
+} | {
+    type: 'fleetUsage';
+    id: string;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+} | {
+    type: 'fleetDone';
+    id: string;
+    status: FleetEntry['status'];
+    iterations: number;
+    toolCalls: number;
+    /** Human-readable failure reason, e.g. "provider_auth", "rate_limit", "timeout". */
+    failureReason?: string | undefined;
+} | {
+    type: 'fleetRemove';
+    id: string;
+} | {
+    type: 'fleetBudgetWarning';
+    id: string;
+    kind: string;
+    used: number;
+    limit: number;
+} | {
+    type: 'fleetBudgetExtended';
+    id: string;
+    totalExtensions: number;
+} | {
+    type: 'fleetCtxPct';
+    id: string;
+    load: number;
+    tokens: number;
+    maxContext: number;
+    /** Estimated USD cost of the context tokens (optional — computed when pricing known). */
+    ctxCost?: number | undefined;
+} | {
+    type: 'fleetCost';
+    cost: number;
+    input?: number | undefined;
+    output?: number | undefined;
+    /** Per-subagent usage keyed by subagent id (from the director snapshot). */
+    perAgent?: Record<string, {
+        cost: number;
+    }>;
+} | {
+    type: 'fleetConcurrency';
+    n: number;
+} | {
+    type: 'eternalStage';
+    stage: AutonomyStage;
+} | {
+    type: 'goalSummary';
+    summary: GoalSummary;
+} | {
+    type: 'goalRunInit';
+    title: string;
+} | {
+    type: 'goalRunPhaseUpdate';
+    phaseId: string;
+    name: string;
+    status: string;
+    completedTasks: number;
+    totalTasks: number;
+    startedAt?: number | undefined;
+} | {
+    type: 'goalRunRunningPhases';
+    phaseIds: string[];
+} | {
+    type: 'goalRunElapsed';
+    ms: number;
+} | {
+    type: 'goalRunTaskActive';
+    phaseId: string;
+    taskId: string;
+    title: string;
+    agent?: string | undefined;
+    /** True when the task starts, false when it completes/fails. */
+    active: boolean;
+} | {
+    /** A task finished successfully; the reducer owns the count arithmetic. */
+    type: 'goalRunTaskCompleted';
+    phaseId: string;
+    taskId: string;
+} | {
+    /** Attach the assigned agent to an already-active task (reducer-owned). */
+    type: 'goalRunTaskAgent';
+    phaseId: string;
+    taskId: string;
+    agent?: string | undefined;
+} | {
+    type: 'goalRunMonitorToggle';
+} | {
+    type: 'goalRunReset';
+} | {
+    type: 'sddBoardSnapshot';
+    snapshot: SddBoardSnapshot;
+} | {
+    type: 'sddBoardFocusNext';
+} | {
+    type: 'sddBoardFocusPrev';
+} | {
+    type: 'worktreeUpsert';
+    handleId: string;
+    row: Partial<WorktreeRow & {
+        baseBranch?: string | undefined;
+    }>;
+    baseBranch?: string | undefined;
+} | {
+    type: 'worktreeRemove';
+    handleId: string;
+} | {
+    type: 'collabBugFound';
+    sessionId: string;
+    bugId: string;
+    severity: string;
+    description: string;
+} | {
+    type: 'collabPlanEmitted';
+    sessionId: string;
+    planId: string;
+    riskScore: string;
+    phaseCount: number;
+} | {
+    type: 'collabEvalComplete';
+    sessionId: string;
+    evalId: string;
+    verdict: string;
+    score: number;
+} | {
+    type: 'collabSessionDone';
+    sessionId: string;
+    verdict: 'approve' | 'needs_revision' | 'reject';
+} | {
+    type: 'collabSubagentSpawned';
+    subagentId: string;
+    role: string;
+};
+//# sourceMappingURL=app-action-workflows.d.ts.map

package/dist/app-main-column.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+/** Main chat column beside the independent sidebar viewport. */
+export declare function AppMainColumn({ width, rows, children, }: {
+    width: number;
+    rows: number;
+    children: ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=app-main-column.d.ts.map

package/dist/app-settings-type.d.ts

@@ -107,7 +107,7 @@ export type Settings = {
      * the CLI boot menu (persistSystemPromptVariant), not the TUI picker, so
      * there is no saveSettings counterpart.
      */
-    systemPromptVariant?: 'lite' | 'default' | 'pro' | undefined;
+    systemPromptVariant?: 'lite' | 'default' | 'pro' | 'scout' | undefined;
     animationStyle: 'rainbow' | 'wave' | 'pulse' | 'dots' | 'breathe' | 'static' | 'cycle';
     /** When true, read tool includes codebase-index symbols alongside file content. */
     readSymbols: boolean;

package/dist/app-state.d.ts

@@ -250,7 +250,17 @@ export type State = PanelState & {
         currentRound: number;
         totalRounds?: number | undefined;
     } | null;
-    /** Incremented on /clear so the context chip re-reads from agent.ctx tokens. */
+    /**
+     * Monotonic re-arm key for the context chip: the statusline and `/context`
+     * read it so they can re-derive their numbers instead of keeping whatever
+     * they last rendered.
+     *
+     * Bumped by `resetContextChip` (dialogs.ts), by `/clear`, and on BOTH
+     * /resume completion branches — with a `contextSnapshot` (reducers/composer.ts)
+     * and without one. The no-snapshot branch still bumps so the chip stops
+     * showing the previous session's tokens rather than sitting on a value that
+     * described a conversation the user already left.
+     */
     contextChipVersion: number;
     /** Live fleet state: per-subagent entries from FleetBus events. Keyed by subagentId. */
     fleet: Record<string, FleetEntry>;

package/dist/app-view-sidebar.d.ts

@@ -1,6 +1,7 @@
 import type React from 'react';
 import type { AppViewProps } from './app-view-contract.js';
 import type { usePlanPanelData } from './components/plan-panel.js';
+import type { QuotaCardModel } from './components/sidebar-quota-model.js';
 import type { useSidebarConnections, useSidebarKanban, useSidebarProcessList, useSidebarWrongProxy } from './hooks/use-sidebar-panel-data.js';
 import type { PanelId } from './ui-contracts.js';
 interface AppViewSidebarProps {
@@ -30,7 +31,9 @@ interface AppViewSidebarProps {
     /** Live probe data from `useSidebarWrongProxy`. `null` while the panel
      *  is bootstrapping or the daemon URL hasn't produced a response yet. */
     sidebarWrongProxyData: ReturnType<typeof useSidebarWrongProxy>;
+    /** PLAN QUOTA card for the active provider/model (`useProviderQuotaCard`). */
+    sidebarQuotaCard?: QuotaCardModel | undefined;
 }
-export declare function AppViewSidebar({ host, runtime, sidebarWidth, sidebarContentWidth, sidebarScrollOffset, sidebarMaxScroll, sidebarSlotVisible, hiddenSidebarPanelCount, sidebarProcessData, sidebarConnectionsData, sidebarKanbanData, sidebarPlanData, sidebarWrongProxyEnabled, sidebarWrongProxyData, }: AppViewSidebarProps): React.ReactElement | null;
+export declare function AppViewSidebar({ host, runtime, sidebarWidth, sidebarContentWidth, sidebarScrollOffset, sidebarMaxScroll, sidebarSlotVisible, hiddenSidebarPanelCount, sidebarProcessData, sidebarConnectionsData, sidebarKanbanData, sidebarPlanData, sidebarWrongProxyEnabled, sidebarWrongProxyData, sidebarQuotaCard, }: AppViewSidebarProps): React.ReactElement | null;
 export {};
 //# sourceMappingURL=app-view-sidebar.d.ts.map

package/dist/components/history/tool-group.d.ts

@@ -1,19 +1,3 @@
-/**
- * tool-group — Consecutive same-tool entries grouped under a single header.
- *
- * Instead of rendering N separate tool cards for N consecutive `read` (or
- * `bash`, `grep`, …) calls, this module collapses them into one visual group:
- *
- *     ╭─ ◆ read ×5  ·  0.5s
- *     │ [1] path/to/a.ts  …
- *     │ [2] path/to/b.tsx …
- *     │ …
- *     ╰──────────────────────────────────────────
- *
- * The group header carries a count badge and aggregated stats; each sub-entry
- * keeps its own arg preview, output, diff, and timing. Non-tool entries and
- * isolated tool entries pass through unchanged.
- */
 import type React from 'react';
 import type { ToolResultViewMode } from '../../tool-result-view-mode.js';
 import type { HistoryEntry } from './types.js';

package/dist/components/sidebar-content.d.ts

@@ -7,6 +7,7 @@ import type { FleetEntry } from '../app-state-fleet.js';
 import type { HeapSample } from '../heap-watchdog.js';
 import type { PanelId } from '../ui-contracts.js';
 import type { LiveSessionEntry } from './sessions-panel.js';
+import type { QuotaCardModel } from './sidebar-quota-model.js';
 interface SidebarContentProps {
     /** Live context window data from useStatusbarViewModel. */
     contextWindow: {
@@ -21,6 +22,12 @@ interface SidebarContentProps {
      * the spend is hitting the prompt cache without opening `/context`.
      */
     cacheStats?: CacheStats | undefined;
+    /**
+     * Subscription quota of the active provider, narrowed to the active model,
+     * plus one row per other provider that has reported. Absent — and the card
+     * not rendered — when no provider meters a plan (API-key sessions).
+     */
+    quota?: QuotaCardModel | undefined;
     /** Fleet entries (leader + subagents) from useStatusbarViewModel. */
     entries: Record<string, FleetEntry>;
     /** Fleet counts summary. */
@@ -80,6 +87,6 @@ interface SidebarContentProps {
      */
     effectiveSidebarRoutes?: ReadonlySet<PanelId> | undefined;
 }
-export declare function SidebarContent({ contextWindow, contextBreakdown, cacheStats, entries, fleetCounts, provider, model, themeName, width, scrollOffset, focused, todos, showSwarmSection, liveSessions, resumeSessions, currentSessionId, processMemory, cpuPercent, cpuHistory, rssHistory, heapHistory, totalMem, effectiveSidebarRoutes, }: SidebarContentProps): React.ReactElement;
+export declare function SidebarContent({ contextWindow, contextBreakdown, cacheStats, quota, entries, fleetCounts, provider, model, themeName, width, scrollOffset, focused, todos, showSwarmSection, liveSessions, resumeSessions, currentSessionId, processMemory, cpuPercent, cpuHistory, rssHistory, heapHistory, totalMem, effectiveSidebarRoutes, }: SidebarContentProps): React.ReactElement;
 export { contextSpectrum, isCurrentSession } from './sidebar-presentation.js';
 //# sourceMappingURL=sidebar-content.d.ts.map

package/dist/components/sidebar-quota-model.d.ts

@@ -0,0 +1,59 @@
+import { type ProviderQuotaSnapshot } from '@wrongstack/core/quota';
+export type QuotaSeverity = 'ok' | 'warn' | 'critical';
+export interface QuotaWindowRow {
+    kind: 'window';
+    label: string;
+    usedPercent: number;
+    resetIn?: string | undefined;
+    reached: boolean;
+    severity: QuotaSeverity;
+}
+export type QuotaCardRow = {
+    kind: 'provider';
+    providerId: string;
+    planLabel?: string | undefined;
+} | {
+    kind: 'meter';
+    title: string;
+} | QuotaWindowRow | {
+    kind: 'pace';
+    exhaustsIn: string;
+} | {
+    kind: 'credits';
+    text: string;
+    empty: boolean;
+} | {
+    kind: 'other';
+    providerId: string;
+    label: string;
+    usedPercent: number;
+    reached: boolean;
+    severity: QuotaSeverity;
+} | {
+    kind: 'more';
+    count: number;
+};
+export interface QuotaCardModel {
+    /**
+     * Header badge: the most-consumed window among the ones this card actually
+     * renders, else of anyone. It must name a window in {@link rows} — the badge
+     * is the first thing read, and a card whose headline is a folded-away bucket
+     * contradicts its own body (and colours itself from that hidden window).
+     */
+    headline?: {
+        label: string;
+        usedPercent: number;
+        reached: boolean;
+        severity: QuotaSeverity;
+    };
+    /** At most {@link SIDEBAR_QUOTA_BODY_ROWS} rows. */
+    rows: QuotaCardRow[];
+}
+/**
+ * Build the card for `activeProviderId` running `activeModel`.
+ *
+ * Returns undefined when no provider has reported anything — the card is not
+ * rendered at all for API-key sessions, which have no plan to meter.
+ */
+export declare function buildQuotaCardModel(snapshots: readonly ProviderQuotaSnapshot[], activeProviderId: string | undefined, activeModel: string | undefined, now?: number, budget?: number): QuotaCardModel | undefined;
+//# sourceMappingURL=sidebar-quota-model.d.ts.map

package/dist/components/sidebar-quota.d.ts

@@ -0,0 +1,7 @@
+import type React from 'react';
+import type { QuotaCardModel } from './sidebar-quota-model.js';
+export declare function QuotaCard({ quota, innerWidth, }: {
+    quota: QuotaCardModel;
+    innerWidth: number;
+}): React.ReactElement;
+//# sourceMappingURL=sidebar-quota.d.ts.map

package/dist/components/status-bar-icons.d.ts

@@ -39,6 +39,7 @@ export declare const STATUSLINE_ICONS: {
     readonly tools: string;
     readonly version: string;
     readonly working_dir: string;
+    readonly sandbox: string;
     readonly yolo: string;
 };
 export declare const COMPACT_THRESHOLD = 50;

package/dist/components/status-bar-rails-common.d.ts

@@ -100,7 +100,7 @@ export interface StatusBarRailBuildParams {
     /** Pre-built memory-context chips for the async rail. */
     memoryDetailChips: RailSpanEntry[];
     /** Active system-prompt variant (Lite / Standard / Pro) — identity chip. */
-    promptVariant?: 'lite' | 'default' | 'pro' | undefined;
+    promptVariant?: 'lite' | 'default' | 'pro' | 'scout' | undefined;
 }
 /**
  * Translate a chip's density setting into the level bounds the rail fitter

package/dist/components/status-bar-types.d.ts

@@ -360,7 +360,7 @@ export interface StatusBarProps {
      * line 1 (workspace & identity) so the session's prompt density is visible
      * at a glance. Sourced from `config.systemPrompt.variant`.
      */
-    promptVariant?: 'lite' | 'default' | 'pro' | undefined;
+    promptVariant?: 'lite' | 'default' | 'pro' | 'scout' | undefined;
     /**
      * Live debug-stream telemetry — pushed into the TUI reducer by the
      * throttled callback from stream-debug-state.ts. When non-null, renders

package/dist/controller-props.d.ts

@@ -0,0 +1,176 @@
+import type { AppProps } from './app-props.js';
+export declare function resolveControllerProps(props: AppProps): {
+    agent: import("@wrongstack/core/agent").Agent;
+    slashRegistry: import("@wrongstack/core/registry").SlashCommandRegistry;
+    secretInputController: {
+        readSecret(prompt: string): Promise<string>;
+        readText?(prompt: string): Promise<string>;
+    } | undefined;
+    attachments: import("@wrongstack/core/types").AttachmentStore;
+    events: import("@wrongstack/core/kernel").EventBus;
+    tokenCounter: import("@wrongstack/core/types").TokenCounter | undefined;
+    model: string;
+    banner: boolean;
+    queueStore: import("@wrongstack/core/storage").QueueStore | undefined;
+    queueStoreFor: ((sessionId: string) => import("@wrongstack/core/storage").QueueStore | undefined) | undefined;
+    onQueueChange: ((items: string[]) => void) | undefined;
+    yolo: boolean;
+    chime: boolean;
+    confirmExit: boolean;
+    titleController: {
+        setEnabled: (on: boolean) => void;
+        setModel: (model: string) => void;
+    } | undefined;
+    mouse: boolean;
+    capability: import("@wrongstack/core/utils").TerminalCapability | undefined;
+    enhanceEnabled: boolean;
+    enhanceController: {
+        enabled: boolean;
+        setEnabled: (enabled: boolean) => void;
+    } | undefined;
+    midRunSendPicker: boolean;
+    enhanceDelayMs: number;
+    getAutonomy: (() => 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') | undefined;
+    getEternalEngine: (() => import('@wrongstack/core/execution').EternalAutonomyEngine | null) | undefined;
+    getParallelEngine: (() => import('@wrongstack/core/execution').ParallelEternalEngine | null) | undefined;
+    getSddRun: (() => import("@wrongstack/sdd").SddRunControl | null) | undefined;
+    subscribeGoal: ((handler: (event: string, payload: unknown) => void) => () => void) | undefined;
+    appVersion: string | undefined;
+    provider: string | undefined;
+    family: string | undefined;
+    keyTail: string | undefined;
+    profile: string | undefined;
+    profileConfigPath: string | undefined;
+    autonomyAgents: import("./history-entry.js").AutonomyAgentStatus[] | undefined;
+    toolCount: number | undefined;
+    getPickableProviders: (() => Promise<import("./ui-contracts.js").ProviderOption[]>) | undefined;
+    switchProviderAndModel: ((providerId: string, modelId: string) => string | null | Promise<string | null>) | undefined;
+    getSettings: (() => import("./app-settings-type.js").Settings) | undefined;
+    saveSettings: ((s: import("./app-settings-type.js").Settings) => string | null | Promise<string | null>) | undefined;
+    getPluginItems: (() => import("./ui-contracts.js").PluginPickerItem[]) | undefined;
+    onPluginToggle: ((name: string) => Promise<{
+        items: import("./ui-contracts.js").PluginPickerItem[];
+        message?: string | undefined;
+        error?: string | undefined;
+    }>) | undefined;
+    getMcpServers: (() => import("./ui-contracts.js").McpPickerItem[]) | undefined;
+    onMcpToggle: ((name: string) => Promise<{
+        items: import("./ui-contracts.js").McpPickerItem[];
+        message?: string | undefined;
+        error?: string | undefined;
+    }>) | undefined;
+    onMcpRestart: ((name: string) => Promise<{
+        items: import("./ui-contracts.js").McpPickerItem[];
+        message?: string | undefined;
+        error?: string | undefined;
+    }>) | undefined;
+    getToolsItems: (() => import("./ui-contracts.js").ToolPickerItem[]) | undefined;
+    onToolToggle: ((name: string) => Promise<{
+        items: import("./ui-contracts.js").ToolPickerItem[];
+        message?: string | undefined;
+        error?: string | undefined;
+    }>) | undefined;
+    getBrainData: (() => {
+        riskLevel: import("./brain-contracts.js").BrainRiskLevel;
+        log: Array<{
+            kind: string;
+            question: string;
+            outcome: string;
+            age: string;
+        }>;
+    }) | undefined;
+    onBrainRiskLevel: ((level: import("./brain-contracts.js").BrainRiskLevel) => string | undefined) | undefined;
+    brainPanelHost: import("./brain-panel-model.js").BrainPanelHost | undefined;
+    subagentModelsHost: import("./subagent-models-panel-model.js").SubagentModelsPanelHost | undefined;
+    getShadowData: (() => {
+        activeId: string | null;
+        running: boolean;
+        model: string;
+        intervalMs: number;
+    }) | undefined;
+    onShadowStart: (() => Promise<string | undefined>) | undefined;
+    onShadowStop: (() => Promise<string | undefined>) | undefined;
+    authHost: import("./auth-panel-model.js").AuthPanelHost | undefined;
+    getSuggestions: (() => string[]) | undefined;
+    getAutoSuggestions: (() => string[]) | undefined;
+    autonomyNextPrompt: string | undefined;
+    setSuggestions: ((steps: string[]) => void) | undefined;
+    switchAutonomy: ((mode: 'off' | 'suggest' | 'auto' | 'eternal' | 'eternal-parallel') => string | null) | undefined;
+    effectiveMaxContext: number | undefined;
+    onExit: (code: number) => void;
+    director: import("@wrongstack/core/coordination").Director | null;
+    getDirector: (() => import("@wrongstack/core/coordination").Director | null) | undefined;
+    onClearHistory: ((dispatch: React.Dispatch<{
+        type: 'clearHistory';
+        model?: string | undefined;
+        provider?: string | undefined;
+    } | {
+        type: 'resetContextChip';
+    } | {
+        type: 'streamReset';
+    } | {
+        type: 'toolStreamClear';
+    }>) => void) | undefined;
+    listSessions: ((limit?: number) => Promise<import("./app-state-core-types.js").ResumeSessionEntry[]>) | undefined;
+    fleetStreamController: {
+        mode: import("@wrongstack/core/types").FleetChatVerbosity;
+        setMode: (mode: import("@wrongstack/core/types").FleetChatVerbosity) => void;
+    } | undefined;
+    interruptController: import("./hooks/use-session-interrupt-controller.js").SessionInterruptController | undefined;
+    statuslineHiddenItems: import("@wrongstack/core/statusline").StatuslineItem[];
+    setStatuslineHiddenItems: (items: import("./ui-contracts.js").StatuslineItem[]) => void;
+    saveStatuslineHiddenItems: (items: import("./ui-contracts.js").StatuslineItem[]) => Promise<void>;
+    statuslineLines: Partial<Record<import("@wrongstack/core/statusline").StatuslineItem, import("@wrongstack/core/statusline").StatuslineLine>> | undefined;
+    setStatuslineLines: ((lines: import("@wrongstack/core/statusline").StatuslineLines) => void) | undefined;
+    saveStatuslineLines: ((lines: import("@wrongstack/core/statusline").StatuslineLines) => Promise<void>) | undefined;
+    statuslineDensities: Partial<Record<import("@wrongstack/core/statusline").StatuslineItem, import("@wrongstack/core/statusline").StatuslineDensity>> | undefined;
+    setStatuslineDensities: ((densities: import("@wrongstack/core/statusline").StatuslineDensities) => void) | undefined;
+    saveStatuslineDensities: ((densities: import("@wrongstack/core/statusline").StatuslineDensities) => Promise<void>) | undefined;
+    statuslineOrder: import("@wrongstack/core/statusline").StatuslineOrder | undefined;
+    setStatuslineOrder: ((order: import("@wrongstack/core/statusline").StatuslineOrder) => void) | undefined;
+    saveStatuslineOrder: ((order: import("@wrongstack/core/statusline").StatuslineOrder) => Promise<void>) | undefined;
+    agentsMonitorController: {
+        visible: boolean;
+        setVisible: (visible: boolean) => void;
+    } | undefined;
+    initialGoal: string | undefined;
+    initialAsk: string | undefined;
+    sessionsDir: string | undefined;
+    modeLabel: string | undefined;
+    getModeLabel: (() => string) | undefined;
+    getModes: (() => Promise<{
+        modes: import('@wrongstack/core/types').Mode[];
+        activeId: string | null;
+    }>) | undefined;
+    registerDebugStreamCallback: ((cb: (stats: {
+        chunkCount: number;
+        lastChunkSize: number;
+        lastDeltaMs: number;
+        totalBytes: number;
+        lastChunkAt: string;
+    }) => void) => void) | undefined;
+    restoreDebugStreamCallback: (() => void) | undefined;
+    restoredMessages: import("@wrongstack/core/types").Message[] | undefined;
+    restoredToolCalls: {
+        name: string;
+        id: string;
+        durationMs: number;
+        ok: boolean;
+        outputBytes?: number | undefined;
+        outputTokens?: number | undefined;
+        outputLines?: number | undefined;
+    }[] | undefined;
+    restoredEvents: import("@wrongstack/core/types").SessionEvent[] | undefined;
+    getProjectPickerItems: (() => Promise<import('./ui-contracts.js').ProjectPickerItem[]>) | undefined;
+    getLiveSessions: (() => Promise<import('./ui-contracts.js').LiveSessionEntry[]>) | undefined;
+    initialAgentsMonitorOpen: boolean | undefined;
+    onPanelOpen: {
+        current: ((action: string) => boolean) | null;
+    } | undefined;
+    subscribeCoordinatorEvents: ((fn: (event: import("@wrongstack/core/coordination").CoordinatorEvent) => void) => () => void) | undefined;
+    coordinatorRunning: boolean;
+    clientId: string | undefined;
+    memoryStore: import("@wrongstack/core/types").MemoryPort | undefined;
+    configStore: import("@wrongstack/core/types").ConfigStore | undefined;
+};
+//# sourceMappingURL=controller-props.d.ts.map

package/dist/hooks/use-provider-quota.d.ts

@@ -16,6 +16,7 @@
  * to move one digit. The value is recomputed whenever a new reading lands,
  * which is exactly when it can have meaningfully changed.
  */
+import { type QuotaCardModel } from '../components/sidebar-quota-model.js';
 /** What the chip renders. Absent until some provider has reported. */
 export interface ProviderQuotaChip {
     /** Provider that reported this window, e.g. `openai-codex`. */
@@ -34,4 +35,13 @@ export interface ProviderQuotaChip {
     exhaustsIn?: string | undefined;
 }
 export declare function useProviderQuota(): ProviderQuotaChip | undefined;
+/**
+ * The sidebar PLAN QUOTA card for the active provider and model.
+ *
+ * Same push-only contract as {@link useProviderQuota}: recomputed when a new
+ * reading lands or the active provider/model changes, never on a timer. While
+ * `enabled` is false (no sidebar on screen) it holds nothing and subscribes to
+ * nothing.
+ */
+export declare function useProviderQuotaCard(enabled: boolean, providerId: string | undefined, model: string | undefined): QuotaCardModel | undefined;
 //# sourceMappingURL=use-provider-quota.d.ts.map

package/dist/hooks/use-resource-slash-commands.d.ts

@@ -1,11 +1,11 @@
 import type { TuiSlashCommandOptions } from './tui-slash-command-options.js';
 /**
- * Resource-domain slash commands (/skill, the seven operational resource-menu
- * browsers fallback/tier/profile/provider-status/memory/worktree/git, and
+ * Resource-domain slash commands (/skill, operational resource-menu
+ * browsers fallback/tier/profile/provider-status/provider-quota/memory/worktree/git, and
  * cron/prompts), moved verbatim from useTuiSlashCommands (decomposition
- * Phase 2 — docs/decomposition-plan.md). Registers at pinned positions
- * 12–21 (tests/slash-registration-enumeration.test.ts), between the session
- * slice's 'mid' part (10–11) and the settings slice's 'appearance' part (22).
+ * Phase 2 — docs/decomposition-plan.md). Registration order is pinned by
+ * tests/slash-registration-enumeration.test.ts, between the session slice's
+ * 'mid' part and the settings slice's 'appearance' part.
  */
 export declare function useResourceSlashCommands(deps: TuiSlashCommandOptions): void;
 //# sourceMappingURL=use-resource-slash-commands.d.ts.map