@wrongstack/webui 0.313.1 → 0.316.1

package/dist/stores/chimera-hub-store.d.ts

@@ -0,0 +1,140 @@
+export interface ChimeraReportSummaryItem {
+    reportId: string;
+    sessionId: string;
+    agentId?: string | undefined;
+    reviewedAt: string;
+    reviewerModel?: string | undefined;
+    source?: string | undefined;
+    reviewStatus?: 'success' | 'failed' | undefined;
+    lifecycleStatus: string;
+    counts?: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    } | undefined;
+    totalFindings: number;
+    fileCount?: number | undefined;
+    durationSeconds?: number | undefined;
+    cascadeDepth?: number | undefined;
+    evidenceStatus?: string | undefined;
+    hasActionableFindings?: boolean | undefined;
+}
+export interface FindingDetailItem {
+    finding: {
+        id: string;
+        fingerprint: string;
+        severity: 'critical' | 'high' | 'medium' | 'low';
+        source: string;
+        location?: {
+            file: string;
+            line?: number | undefined;
+        } | undefined;
+        category?: string | undefined;
+        confidence?: string | undefined;
+        verification?: {
+            status: string;
+            reason: string;
+            evidence?: string | undefined;
+        } | undefined;
+        title: string;
+        description: string;
+        suggestedFix?: string | undefined;
+        createdAt: string;
+        status: string;
+        resolution?: {
+            outcome: string;
+            resolvedAt: string;
+            resolvedBy: string;
+            commitSha?: string | undefined;
+            notes?: string | undefined;
+        } | undefined;
+        originReport: {
+            reportId: string;
+            sessionId: string;
+            agentId: string;
+            reviewerModel: string;
+        };
+    };
+    events: Array<{
+        id: string;
+        findingId: string;
+        eventType: string;
+        fromStatus: string | null;
+        toStatus: string;
+        actorId: string;
+        actorKind: string;
+        timestamp: string;
+        reason?: string | undefined;
+    }>;
+}
+export interface ChimeraReportFullDetail {
+    report: {
+        id: string;
+        reviewedAt: string;
+        sessionId: string;
+        agentId: string;
+        reviewerModel: string;
+        source: string;
+        reviewStatus: 'success' | 'failed';
+        lifecycle: string;
+        files: Array<{
+            path: string;
+            status: string;
+        }>;
+        counts: {
+            critical: number;
+            high: number;
+            medium: number;
+            low: number;
+        };
+        totalFindings: number;
+        unparseableCount: number;
+        durationSeconds?: number | undefined;
+        rawText: string;
+        cascadeDepth?: number | undefined;
+        evidenceStatus?: string | undefined;
+        evidenceChecks?: Array<{
+            name: string;
+            command: string;
+            ok: boolean;
+            claimedExitCode?: number | null;
+            actualExitCode?: number | null;
+        }> | undefined;
+    } | null;
+    findings: FindingDetailItem[];
+    events: Array<{
+        id: string;
+        reportId: string;
+        eventType: string;
+        fromLifecycle: string | null;
+        toLifecycle: string;
+        actorId: string;
+        actorKind: string;
+        timestamp: string;
+        reason?: string | undefined;
+    }>;
+}
+interface ChimeraHubState {
+    reports: ChimeraReportSummaryItem[];
+    selectedReportId: string | null;
+    detail: ChimeraReportFullDetail | null;
+    loading: boolean;
+    detailLoading: boolean;
+    error: string | null;
+    filterSessionId: string;
+    filterLifecycle: string;
+    searchQuery: string;
+    fetchReports: () => void;
+    selectReport: (reportId: string | null) => void;
+    setFilterSessionId: (sessionId: string) => void;
+    setFilterLifecycle: (lifecycle: string) => void;
+    setSearchQuery: (query: string) => void;
+    transitionReport: (reportId: string, to: string, reason?: string) => void;
+    addReportNote: (reportId: string, note: string) => void;
+    transitionFinding: (findingId: string, to: string, outcome?: string, reason?: string) => void;
+}
+export declare function ensureChimeraHubHandlersInstalled(): void;
+export declare const useChimeraHubStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ChimeraHubState>>;
+export {};
+//# sourceMappingURL=chimera-hub-store.d.ts.map

package/dist/stores/chimera-reports-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * chimera-reports-store.ts — Per-session registry of Chimera review reports.
+ *
+ * ONE LIST PER TAB. A Chimera report names the session it reviewed, so it
+ * belongs to that session's tab and to no other — the same positive-routing
+ * rule the chat lanes follow. This store is the identity/bookkeeping layer:
+ * the transcript card is the visible surface, while this store dedupes by
+ * reportId so a live `chimera.report_available` event and a `chimera.reports`
+ * hydration response never produce two cards for one report, and it remembers
+ * which reports the user already actioned.
+ *
+ * Why a store at all (and not just lane messages): a report can arrive while
+ * its session's lane does not exist yet or all four lane slots are taken;
+ * the registry keeps it addressable so the next tab activation can
+ * re-materialize the card from the server's persisted list.
+ */
+/** One surfacable Chimera review report for a session tab. */
+export interface ChimeraReportNotice {
+    /** Review run id — the dedupe key within a session. */
+    reportId: string;
+    sessionId: string;
+    /** Human-readable summary from the live event (generic text when hydrated). */
+    message: string;
+    findingCount: number;
+    fileCount: number;
+    hasActionableFindings: boolean;
+    /** ms epoch — arrival time (event) or review completion time (hydration). */
+    receivedAt: number;
+    /** When this tab's one-click prompt was sent to the leader; null until then. */
+    actionedAt: number | null;
+    /** Where the notice came from: the live event or a server list hydration. */
+    source: 'event' | 'hydrate';
+}
+interface ChimeraReportsState {
+    bySession: Record<string, ChimeraReportNotice[]>;
+    /** Record a report. Returns false when the reportId is already known. */
+    recordReport: (notice: ChimeraReportNotice) => boolean;
+    markActioned: (sessionId: string, reportId: string, at: number) => void;
+    /** Merge server-hydrated reports; unknown reportIds only, never clobbers actionedAt. */
+    hydrateReports: (sessionId: string, notices: ChimeraReportNotice[]) => void;
+    forgetSession: (sessionId: string) => void;
+}
+export declare const useChimeraReportsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ChimeraReportsState>>;
+export {};
+//# sourceMappingURL=chimera-reports-store.d.ts.map

package/dist/stores/codemap-activity-store.d.ts

@@ -1,14 +1,14 @@
 import type { WSServerMessage } from '../types';
 export type ActivityType = 'read' | 'write' | 'edit' | 'delete' | 'search' | 'memory' | 'index' | 'execute';
-export type ActivityStatus = 'active' | 'completed' | 'failed' | 'observed';
-export type ActivitySource = 'tool' | 'editor' | 'deterministic' | 'watcher' | 'external' | 'legacy';
-export interface ActivitySymbol {
+type ActivityStatus = 'active' | 'completed' | 'failed' | 'observed';
+type ActivitySource = 'tool' | 'editor' | 'deterministic' | 'watcher' | 'external' | 'legacy';
+interface ActivitySymbol {
     id: string;
     name: string;
     kind?: string | undefined;
     line?: number | undefined;
 }
-export interface ActivityChange {
+interface ActivityChange {
     added: number;
     removed: number;
     before?: string | undefined;

package/dist/stores/context-editor-store.d.ts

@@ -1,5 +1,5 @@
 import type { ContextEditorMessage, ContextEditorMetrics, ContextEditorRemoval, ContextEditorRepairPreview, ContextEditorValidationError, ContextEditorWarning, ContextEditorConflict, ContextEditorDiagnostics } from '@/types/runtime';
-export type ContextEditorPhase = 'closed' | 'loading_snapshot' | 'clean_snapshot' | 'dirty' | 'validating' | 'validated' | 'invalid' | 'conflicted' | 'applying' | 'applied_success' | 'apply_failed';
+type ContextEditorPhase = 'closed' | 'loading_snapshot' | 'clean_snapshot' | 'dirty' | 'validating' | 'validated' | 'invalid' | 'conflicted' | 'applying' | 'applied_success' | 'apply_failed';
 interface ReadonlyContext {
     systemPromptTokens: number;
     toolSchemaTokens: number;
@@ -37,7 +37,7 @@ interface AppliedResult {
     };
     warnings: ContextEditorWarning[];
 }
-export interface ContextEditorState {
+interface ContextEditorState {
     phase: ContextEditorPhase;
     revision: string | null;
     messages: ContextEditorMessage[];
@@ -52,7 +52,7 @@ export interface ContextEditorState {
     appliedResult: AppliedResult | null;
     errorMessage: string | null;
 }
-export interface ContextEditorActions {
+interface ContextEditorActions {
     open: () => void;
     close: () => void;
     loadSnapshot: (payload: {
@@ -74,8 +74,7 @@ export interface ContextEditorActions {
     /** Derive the proposed messages from snapshot minus removals. */
     getProposedMessages: () => ContextEditorMessage[];
 }
-export type ContextEditorStore = ContextEditorState & ContextEditorActions;
-export declare function findPairedAssistantIndices(messages: readonly ContextEditorMessage[], userIndex: number): number[];
+type ContextEditorStore = ContextEditorState & ContextEditorActions;
 export declare const useContextEditorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ContextEditorStore>>;
 export {};
 //# sourceMappingURL=context-editor-store.d.ts.map

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

@@ -81,7 +81,7 @@ export interface BudgetAlert {
     decision?: 'extend' | 'deny';
     newLimit?: number;
 }
-export interface CoordinatorMonitorState {
+interface CoordinatorMonitorState {
     coordinatorStatus: CoordinatorStatus;
     coordinatorMode?: string;
     subagents: Map<string, SubagentEntry>;
@@ -129,5 +129,6 @@ export interface CoordinatorMonitorState {
     recordBudgetExtended: (subagentId: string, kind: string, extendedTo?: number) => void;
     clear: () => void;
 }
-export declare const useCoordinatorMonitorStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CoordinatorMonitorState>>;
+export declare const useCoordinatorMonitorStore: import("./session-scoped-store").SessionScopedStore<CoordinatorMonitorState>;
+export {};
 //# sourceMappingURL=coordinator-monitor-store.d.ts.map

package/dist/stores/council-log-store.d.ts

@@ -1,22 +1,4 @@
-export type CouncilVoteStatus = 'valid' | 'invalid' | 'failed' | 'cancelled';
-/** One seat's observable vote. No hidden chain-of-thought is retained. */
-export interface CouncilSeatVote {
-    seatId: string;
-    persona: string;
-    status: CouncilVoteStatus | string;
-    /** The option this seat voted for, on an option-bearing question. */
-    optionId?: string | undefined;
-    /** Free-text stance / rationale — only present when trace content is 'full'. */
-    stance?: string | undefined;
-    rationale?: string | undefined;
-    providerId?: string | undefined;
-    model?: string | undefined;
-    veto?: boolean | undefined;
-    weight?: number | undefined;
-    durationMs?: number | undefined;
-    error?: string | undefined;
-    at: number;
-}
+import type { CouncilSeatVote } from './types';
 export interface CouncilPanelEntry {
     requestId: string;
     /** `voting` until the resolution lands; a failed council can stay here. */
@@ -62,6 +44,10 @@ export declare function toCouncilSeatVote(payload: Record<string, unknown>, now:
 export declare function summarizeCouncilPanel(entry: CouncilPanelEntry): string;
 /** True when the panel resolved to a refusal, denial or non-verdict. */
 export declare function isCouncilPanelAdverse(entry: CouncilPanelEntry): boolean;
-export declare const useCouncilLogStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CouncilLogState>>;
+/**
+ * One log per conversation: a council convened for tab 3's decision is tab 3's
+ * record, and must not appear in — or be lost because of — tab 1's panel.
+ */
+export declare const useCouncilLogStore: import("./session-scoped-store").SessionScopedStore<CouncilLogState>;
 export {};
 //# sourceMappingURL=council-log-store.d.ts.map

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

@@ -16,6 +16,17 @@ export interface OpenFile {
     /** The content last known to be on disk — used for dirty detection. */
     savedContent: string;
 }
+interface FileSessionState {
+    projectRoot: string;
+    tree: TreeNode[];
+    openFiles: OpenFile[];
+    activeFilePath: string | null;
+    treeLoading: boolean;
+    error: string | null;
+    targetLine: FileStoreState['targetLine'];
+    projectIdentity: string;
+    hydratingPaths: ReadonlySet<string>;
+}
 export interface FileStoreState {
     /** The project root path as reported by the server. */
     projectRoot: string;
@@ -34,19 +45,19 @@ export interface FileStoreState {
         line: number;
         col?: number | undefined;
     } | null;
-    setTree: (root: string, tree: TreeNode[]) => void;
-    openFile: (filePath: string, content: string) => void;
-    closeFile: (filePath: string) => void;
-    setActiveFile: (filePath: string | null) => void;
-    jumpToLine: (line: number, col?: number) => void;
+    setTree: (root: string, tree: TreeNode[], sessionId?: string | null | undefined) => void;
+    openFile: (filePath: string, content: string, sessionId?: string | null | undefined) => void;
+    closeFile: (filePath: string, sessionId?: string | null | undefined) => void;
+    setActiveFile: (filePath: string | null, sessionId?: string | null | undefined) => void;
+    jumpToLine: (line: number, col?: number, sessionId?: string | null | undefined) => void;
     clearTargetLine: () => void;
     updateContent: (filePath: string, content: string) => void;
     /** Mark a file as saved (synced with disk). */
-    markSaved: (filePath: string) => void;
-    setTreeLoading: (loading: boolean) => void;
-    setError: (error: string | null) => void;
+    markSaved: (filePath: string, sessionId?: string | null | undefined) => void;
+    setTreeLoading: (loading: boolean, sessionId?: string | null | undefined) => void;
+    setError: (error: string | null, sessionId?: string | null | undefined) => void;
     /** Drop all open tabs (used when the server switches to a different project). */
-    clearOpenTabs: () => void;
+    clearOpenTabs: (sessionId?: string | null | undefined) => void;
     /**
      * Canonical absolute project root as reported by the server environment
      * (working_dir.changed / session env). Distinct from `projectRoot`, which
@@ -56,16 +67,23 @@ export interface FileStoreState {
      */
     projectIdentity: string;
     /** Record the canonical absolute project root (env events only). */
-    setProjectIdentity: (root: string) => void;
+    setProjectIdentity: (root: string, sessionId?: string | null | undefined) => void;
     /** Paths whose rehydrated stub content is currently being fetched. */
     hydratingPaths: ReadonlySet<string>;
+    setHydratingPaths: (paths: Iterable<string>, sessionId?: string | null | undefined) => void;
+    /** Which session the file editor projection currently describes. */
+    fileSessionId: string | null;
+    /** Per-session open editor tabs and jump targets. */
+    filesBySession: Record<string, FileSessionState>;
+    bindSessionFiles: (sessionId: string | null) => void;
+    forgetSessionFiles: (sessionId: string) => void;
     /**
      * Apply fetched content to a rehydrated stub tab. Only applies while the
      * path is still hydrating AND the tab is still a pristine stub — never
      * overwrites content the user has started editing, never steals focus.
      * Returns true when the content was applied.
      */
-    hydrateFileContent: (filePath: string, content: string) => boolean;
+    hydrateFileContent: (filePath: string, content: string, sessionId?: string | null | undefined) => boolean;
     /**
      * Handle a failed hydration read (file deleted or renamed on disk while
      * the page was closed). Removes the path from hydration tracking and
@@ -73,10 +91,10 @@ export interface FileStoreState {
      * let the next save resurrect a deleted file. A tab the user has started
      * editing is kept; its save recreates the file intentionally.
      */
-    hydrateFileFailed: (filePath: string) => void;
+    hydrateFileFailed: (filePath: string, sessionId?: string | null | undefined) => void;
 }
 /** Shape written to localStorage — tabs are paths only, never content. */
-export interface PersistedFileStoreState {
+interface PersistedFileStoreState {
     openFilePaths: string[];
     activeFilePath: string | null;
     /** Canonical absolute project root (env identity), not the display label. */
@@ -106,4 +124,5 @@ export declare const useFileStore: import("zustand").UseBoundStore<Omit<import("
         getOptions: () => Partial<import("zustand/middleware").PersistOptions<FileStoreState, PersistedFileStoreState, unknown>>;
     };
 }>;
+export {};
 //# sourceMappingURL=file-store.d.ts.map

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

@@ -1,8 +1,12 @@
 import type { AgentTranscriptEntry, FleetTimelineEvent, SubagentEvent, SubagentView } from './types.js';
 export declare const EMPTY_AGENT_TRANSCRIPT: AgentTranscriptEntry[];
-interface FleetState {
+export interface FleetState {
     agents: Map<string, SubagentView>;
-    /** Current leader agent ID (set via leader_updated event). */
+    /**
+     * Process-wide LAST-ANNOUNCED leader (set via leader_updated). Tab-scoped
+     * consumers must use `selectSessionLeaderId` / `useSessionLeaderId`, which
+     * resolve the leader of ONE session from the roster's isLeader flag.
+     */
     leaderId: string | undefined;
     /** Fleet-wide aggregated tokens (sum of all agent tokens). */
     fleetTokensIn: number;
@@ -30,8 +34,18 @@ interface FleetState {
     getAgentsBySession: (sessionId: string) => SubagentView[];
     /** Return one agent's full ordered transcript. */
     getAgentTranscript: (subagentId: string) => AgentTranscriptEntry[];
-    /** Remove all non-running agents (completed, failed, timeout, stopped) from the roster. */
-    clearFinishedAgents: () => void;
+    /** Hydrate subagent virtual sessions and historical transcripts (from session.start replay). */
+    hydrateAgentSessions: (sessions: Array<{
+        subagentId: string;
+        agentName?: string | undefined;
+        status?: string | undefined;
+        task?: string | undefined;
+        transcript?: AgentTranscriptEntry[] | undefined;
+    }>, sessionId?: string | undefined) => void;
+    /** Remove non-running agents (completed, failed, timeout, stopped) from the
+     *  roster. Scoped: only agents belonging to `sessionId` are removed, so a
+     *  panel in one tab never drops another tab's finished agents. */
+    clearFinishedAgents: (sessionId: string | null) => void;
 }
 export declare const useFleetStore: import("zustand").UseBoundStore<import("zustand").StoreApi<FleetState>>;
 /** Pre-computed fleet-wide summary statistics. */
@@ -66,9 +80,39 @@ export declare const selectFleetSummary: (state: FleetState) => FleetSummary;
 /** Selector: return agents sorted leader-first → running-first → by start time.
  *  Creates a new array on every call; wrap with `useShallow` when subscribing
  *  through useFleetStore.
+ *
+ *  Leader-first ordering honors EVERY session's leader (`isLeader` flag),
+ *  not the process-wide `leaderId` pointer: that pointer is last-writer-wins
+ *  across four tabs, so sorting by it crowned only the most recently
+ *  announced tab's leader and demoted the other three on every announce.
  */
 export declare const selectSortedAgentList: (state: FleetState) => SubagentView[];
 /** Selector: O(1) lookup of the leader agent's name via the agents Map. */
 export declare const selectLeaderName: (state: FleetState) => string | undefined;
-export {};
+export interface SessionFleetTotals {
+    /** The leader of THIS session, or undefined when it has none. */
+    leaderId: string | undefined;
+    tokensIn: number;
+    tokensOut: number;
+    totalCost: number;
+    running: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+/** Fleet totals for ONE session. Never mutate the result — it is cached. */
+export declare const selectSessionFleetTotals: (state: FleetState, sessionId: string | undefined) => SessionFleetTotals;
+/**
+ * The leader of ONE session.
+ *
+ * Falls back to the process-wide `leaderId` only when that agent actually
+ * belongs to the session asked about — a leader that belongs to another tab
+ * must never be reported here, which is exactly the crown-on-the-wrong-card
+ * bug this replaces.
+ */
+export declare const selectSessionLeaderId: (state: FleetState, sessionId: string | undefined) => string | undefined;
+/** Hook: the leader of the tab in front (or of `sessionId` when given). */
+export declare function useSessionLeaderId(sessionId?: string | undefined): string | undefined;
+/** Hook: fleet totals for the tab in front (or for `sessionId` when given). */
+export declare function useSessionFleetTotals(sessionId?: string | undefined): SessionFleetTotals;
 //# sourceMappingURL=fleet-store.d.ts.map

package/dist/stores/git-changes-store.d.ts

@@ -16,21 +16,45 @@ export interface GitDiffContent {
     tooLarge?: boolean;
     error?: string;
 }
+interface GitChangesSessionState {
+    selectedPath: string | null;
+    diff: GitDiffContent | null;
+    loadingDiff: boolean;
+}
 interface GitChangesState {
     files: GitChangedFile[];
     /** Set when the last `git.changes` reply carried an error (e.g. not a repo). */
     error: string | null;
+    /**
+     * Repo→project path prefix ('' when the project root is the repo root),
+     * server-computed via repoRelativePrefix. Git paths are repo-root-
+     * relative while FileExplorer tree paths are project-root-relative;
+     * prepend this to a tree path to build its git lookup key.
+     */
+    repoPrefix: string;
+    /**
+     * Server-computed aggregate status per directory (repo-relative keys) —
+     * the highest-ranked child status (U > D > M > R/C > A > ?), shipped in
+     * git.changes. Replaces the old client-side prefix-scan heuristic.
+     */
+    dirs: Record<string, string>;
     loadingList: boolean;
     /** Repo-relative path of the file whose diff is shown in the main pane. */
     selectedPath: string | null;
     /** Diff body for `selectedPath` (null while loading or before selection). */
     diff: GitDiffContent | null;
     loadingDiff: boolean;
-    setFiles: (files: GitChangedFile[], error: string | null) => void;
+    /** Which session the selected diff projection currently describes. */
+    gitChangesSessionId: string | null;
+    /** Per-session selected diff state. The changed-file list itself is project-global. */
+    gitChangesBySession: Record<string, GitChangesSessionState>;
+    setFiles: (files: GitChangedFile[], error: string | null, repoPrefix?: string, dirs?: Record<string, string>) => void;
     setListLoading: (loading: boolean) => void;
     select: (path: string | null) => void;
     setDiff: (diff: GitDiffContent | null) => void;
     setDiffLoading: (loading: boolean) => void;
+    bindSessionGitChanges: (sessionId: string | null) => void;
+    forgetSessionGitChanges: (sessionId: string) => void;
     clear: () => void;
 }
 export declare const useGitChangesStore: import("zustand").UseBoundStore<import("zustand").StoreApi<GitChangesState>>;

package/dist/stores/goal-run-store.d.ts

@@ -1,7 +1,7 @@
 import type { PhaseItem } from '@/components/PhasePanel';
-export type GoalRunStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed' | 'stopped';
+type GoalRunStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed' | 'stopped';
 /** A persisted kanban board (one Goal graph JSON per board on disk). */
-export interface GoalRunBoardSummary {
+interface GoalRunBoardSummary {
     id: string;
     title: string;
     updatedAt: number;

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

@@ -8,6 +8,17 @@ interface HistoryState {
     removeEntry: (id: string) => void;
     /** Optimistically patch an entry's name (cleared when `name` is empty). */
     updateEntryName: (id: string, name: string) => void;
+    /**
+     * Re-point the `isCurrent` flag at the tab now in front.
+     *
+     * The list itself is project-wide, but `isCurrent` is not: it disables the
+     * resume button, drives the "active" filter, and spares a row from the
+     * empty-session sweep. The server can only answer one session per frame,
+     * and `session.new` BROADCASTS a list to every socket — so the flag is
+     * settled here, where the foreground session is known, instead of trusting
+     * whichever session the last frame happened to be about.
+     */
+    rebindCurrent: (sessionId: string | null) => void;
     clearHistory: () => void;
 }
 export declare const useHistoryStore: import("zustand").UseBoundStore<import("zustand").StoreApi<HistoryState>>;

package/dist/stores/index.d.ts

@@ -1,18 +1,24 @@
 export { useChatStore } from './chat-store.js';
+export type { ChimeraReportNotice } from './chimera-reports-store.js';
+export { useChimeraReportsStore } from './chimera-reports-store.js';
 export type { ActivityType, FileActivity } from './codemap-activity-store.js';
 export { extractActivitiesFromMessage, useCodemapActivityStore, } from './codemap-activity-store.js';
 export type { ConfigState } from './config-store.js';
 export { useConfigStore } from './config-store.js';
 export type { BudgetAlert, BudgetKind, ConsensusResult, ConsensusVote, CoordinatorStatus, FleetEvent, SubagentEntry, TaskEntry, VoteValue, } from './coordinator-monitor-store.js';
 export { useCoordinatorMonitorStore } from './coordinator-monitor-store.js';
+export type { CouncilPanelEntry } from './council-log-store.js';
+export { isCouncilPanelAdverse, MAX_COUNCIL_PANELS, summarizeCouncilPanel, toCouncilSeatVote, useCouncilLogStore, } from './council-log-store.js';
 export type { CronJobView, CronSnapshot } from './cron-store.js';
 export { useCronStore } from './cron-store.js';
+export type { FallbackCandidate, FallbackPendingState } from './fallback-store.js';
+export { useFallbackStore } from './fallback-store.js';
 export type { FileReference, FileReferenceInput } from './file-reference-store.js';
 export { refLabel, refsToMarkdown, useFileReferenceStore, } from './file-reference-store.js';
 export type { OpenFile, TreeNode } from './file-store.js';
 export { useFileStore } from './file-store.js';
-export { EMPTY_AGENT_TRANSCRIPT, selectFleetSummary, selectLeaderName, selectSortedAgentList, shallow, useFleetStore } from './fleet-store.js';
-export type { FleetSummary } from './fleet-store.js';
+export type { FleetSummary, SessionFleetTotals } from './fleet-store.js';
+export { EMPTY_AGENT_TRANSCRIPT, selectFleetSummary, selectLeaderName, selectSessionFleetTotals, selectSessionLeaderId, selectSortedAgentList, shallow, useFleetStore, useSessionFleetTotals, useSessionLeaderId, } from './fleet-store.js';
 export type { GitChangedFile, GitDiffContent } from './git-changes-store.js';
 export { useGitChangesStore } from './git-changes-store.js';
 export type { GitInfo } from './git-info-store.js';
@@ -27,21 +33,23 @@ export type { MailboxAgent, MailboxMessage } from './mailbox-store.js';
 export { selectUnreadCount, useMailboxStore } from './mailbox-store.js';
 export type { ClientCounts, CurrentSessionStats, MailActivity } from './monitor-store.js';
 export { useMonitorStore } from './monitor-store.js';
+export type { AppNotification, NotificationAction, NotificationStoreState, NotificationVariant, } from './notification-store.js';
+export { toast, useNotificationStore, useToastStore, } from './notification-store.js';
 export { type BackgroundStyle, DEFAULT_WAIT_THRESHOLD_MS, useOfficeMapStore, WAIT_THRESHOLD_PRESETS, } from './office-map-store.js';
-export { type ProviderHealthEntry, type ProviderHealthState, useProviderStatusStore, } from './provider-status-store.js';
-export { useFallbackStore } from './fallback-store.js';
-export type { FallbackCandidate, FallbackPendingState } from './fallback-store.js';
+export { type ProviderAuditEntry, type ProviderHealthEntry, type ProviderHealthState, useProviderStatusStore, } from './provider-status-store.js';
 export { type SddBoardFeedEntry, type SddBoardSnapshotUI, type SddBoardStatus, type SddBoardSummary, type SddLifecycleResultUI, useSddBoardStore, } from './sdd-board-store.js';
 export { type SddWizardPhase, type SddWizardSnapshot, useSddWizardStore, } from './sdd-wizard-store.js';
-export { useSessionStore } from './session-store.js';
+/** The lane pointer — the single answer to "which tab is in front". */
+export { activeSessionLaneId, useActiveSessionId } from './session-lanes.js';
+export { memorySessionSnapshots, useSessionStore } from './session-store.js';
+export { isTabBusy, MAX_OPEN_TABS, slotOf, summarizeTab, type TabSummary, useSessionTabStore } from './session-tab-store.js';
 export { type SideEffectEntry, useSideEffectStore } from './side-effect-store.js';
 export { type BoardTaskItem, type BoardTaskStatus, type SpecColumn, type SpecDetail, type SpecListItem, useSpecsStore, } from './specs-store.js';
 export { type TechStackCoverage, type TechStackDependency, type TechStackEvidence, type TechStackFinding, type TechStackFindingAction, type TechStackFindingSeverity, type TechStackFindingType, type TechStackJobKind, type TechStackJobStatus, type TechStackJobView, type TechStackProgress, type TechStackSnapshot, type TechStackWorkspace, useTechStackStore, } from './techstack-store.js';
-export type { AgentTranscriptEntry, AgentTranscriptKind, ChatMessage, FleetTimelineEvent, MessageContent, SessionHistoryEntry, SessionInfo, SubagentEvent, SubagentView, ToolExecution, } from './types.js';
+export { bucketSuccessRatio, LEADER_AGENT_KEY, sessionInFlight, type ToolStatsBucket, type ToolStatsDelegation, type ToolStatsSession, useToolStatsStore, } from './tool-stats-store.js';
+export type { AgentTranscriptEntry, AgentTranscriptKind, BrainDecisionData, ChatMessage, ChatMessageAttachment, CouncilDecisionData, CouncilSeatVote, FleetTimelineEvent, SessionHistoryEntry, SessionInfo, SubagentEvent, SubagentView, ToolExecution } from './types.js';
 export type { Activity, DockSection, InspectorTab, WorkDashboardTab } from './ui-store.js';
 export { coerceActivity, resetUiNavigationToHome, SIDEBAR_DEFAULT_WIDTH, SIDEBAR_MAX_WIDTH, SIDEBAR_MIN_WIDTH, useUIStore, } from './ui-store.js';
-export type { CouncilPanelEntry, CouncilSeatVote } from './council-log-store.js';
-export { isCouncilPanelAdverse, MAX_COUNCIL_PANELS, summarizeCouncilPanel, toCouncilSeatVote, useCouncilLogStore, } from './council-log-store.js';
 export type { VizEdge, VizEvent, VizNode } from './viz-store.js';
 export { useVizStore } from './viz-store.js';
 export { useWorktreeStore } from './worktree-store.js';