@wrongstack/webui 0.313.1 → 0.316.2

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

@@ -0,0 +1,197 @@
+/**
+ * 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.
+ */
+import { chatLane } from './chat-lanes';
+export declare const MAX_OPEN_TABS = 4;
+export declare const TAB_STORAGE_KEY = "wrongstack.open_session_tabs";
+export declare function readStoredTabs(): string[];
+export declare function writeStoredTabs(tabs: string[]): void;
+export interface OpenTabResult {
+    success: boolean;
+    reason: 'already_active' | 'switched' | 'opened_new_tab' | 'replaced_empty_tab' | 'tabs_full';
+}
+/** What the tab strip and the tab map render for one slot. */
+export interface TabSummary {
+    slot: number;
+    sessionId: string;
+    isActive: boolean;
+    title: string;
+    provider: string;
+    model: string;
+    mode: string;
+    isRunning: boolean;
+    messageCount: number;
+    unread: number;
+    queued: number;
+    agentsRunning: number;
+    agentsTotal: number;
+    tokens: number;
+    cost: number;
+    contextPct: number;
+    needsAttention: boolean;
+}
+interface SessionTabState {
+    /** Slot order. Length is always <= MAX_OPEN_TABS. */
+    openTabIds: string[];
+    /** Transcript length each tab had when the user last looked at it. */
+    lastSeenCounts: Record<string, number>;
+    /** Tabs with a tool confirmation waiting. Set by the confirm handler. */
+    attention: Record<string, boolean>;
+    setOpenTabIds: (ids: string[]) => void;
+    openTab: (sessionId: string, options?: {
+        resumeSession?: (id: string) => void;
+        recycleReentry?: boolean;
+    }) => OpenTabResult;
+    closeTab: (sessionId: string) => void;
+    /**
+     * Close every open tab bound to one of `sessionIds` so the caller can ask
+     * the server to delete those records (a session a connection still
+     * declares is refused). Returns the subset that is safe to delete:
+     * sessions without a busy tab, minus the one tab kept so the strip never
+     * drops to zero.
+     */
+    closeTabsForSessions: (sessionIds: string[]) => string[];
+    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.
+ *
+ * `closeTab` and `setOpenTabIds` both retire a tab, and they used to free
+ * different things: the lanes always, the preference overrides and
+ * auto-submit streak only on the explicit close. A tab dropped by the other
+ * path left state that the NEXT session to be handed that id silently
+ * inherited, which is the one thing the four-lane model exists to prevent.
+ * The boot-time lane/slot reconciler in `useF5Resilience` retires through this
+ * same path for the same reason. `restoreOpenTabsOnBoot` is the symmetric
+ * opposite: it REBINDS every persisted slot so a browser refresh leaves the
+ * user's tabs where they were, not as a half-empty welcome screen.
+ */
+export declare function releaseTab(sessionId: string): void;
+/**
+ * Foreground picker for `restoreOpenTabsOnBoot`. Deterministic for tests.
+ *
+ * The persisted `openTabIds` order reflects the user's last tab strip;
+ * `lastVisitedAt` is per-tab and survives F5 inside `useSessionLanes`.
+ * Picking the most-recently-visited tab and falling back to the persisted
+ * order on a tie keeps the foreground where the user left it without
+ * inventing a new ordering rule. The `now` parameter is injected so the
+ * helper stays pure and testable.
+ */
+type RestorePickForeground = (candidates: string[], now: number) => string | null;
+interface RestoreOpenTabsOptions {
+    /** Injected clock for tests. Defaults to `Date.now()`. */
+    now?: number;
+    /** Injected picker for tests. Defaults to `defaultPickForeground`. */
+    pickForeground?: RestorePickForeground;
+}
+/**
+ * Promote the persisted slot list into active, foregrounded tabs at boot.
+ *
+ * The inverse of `releaseTab`: every id stored in
+ * `wrongstack.open_session_tabs` has its chat lane and session lane
+ * ensured, its per-session preferences bound, and its subagent focus and
+ * history rebinds wired up. The most-recently-visited id (or the first
+ * stored id on a tie) becomes the foreground, re-routing through
+ * `activate()` so URL sync, modal disposal, slash-overlay closing and
+ * history rebinding happen exactly the way they do when the user clicks
+ * the tab. Finally the open set is declared to the WS client so the
+ * server resumes broadcasts to all four lanes on the very first paint.
+ *
+ * Called once from `useF5Resilience` at app mount; safe to call again
+ * later but a no-op once the foreground has been set.
+ */
+/**
+ * Drop persisted tabs the SERVER is not holding, and return what survives.
+ *
+ * The tab strip lives in `localStorage`, so it outlives the process that
+ * created it. After a restart every id in it names a session this runtime has
+ * never heard of — and promoting them anyway is what made a fresh
+ * `wstack --webui` open wearing the previous run's tabs, front a conversation
+ * from days ago, and sit through a full journal resume (todo board included)
+ * before the user had typed a character.
+ *
+ * A dropped tab is not a deleted session: the transcript stays on disk and in
+ * History, where reopening it is an explicit act. This only says it is no
+ * longer *open*.
+ *
+ * `live` is the runtime's own list (`openSessionIds` on the boot frame). An
+ * empty or absent list means "trust nothing" and is treated as no tabs — the
+ * caller then seeds the strip with the session the server just announced.
+ */
+export declare function pruneTabsToLiveSessions(live: readonly string[]): string[];
+/** Test seam — lets a suite re-arm the one-shot latch. */
+export declare function resetBootRestoreLatchForTests(): void;
+/**
+ * Reconcile the persisted tab strip with the server, then promote what is left.
+ *
+ * Runs once per page load, driven by whichever comes first:
+ *
+ * - the boot `session.start` frame, which carries `openSessionIds` — the
+ *   sessions this runtime is actually holding. Stale slots are dropped, and if
+ *   NOTHING survives the strip stays empty so the announced session becomes the
+ *   single tab. That is the whole point: a fresh `wstack --webui` must open on
+ *   an empty conversation, not on a tab strip from a previous run.
+ * - a fallback timer, for a server too old to send the field or a page that
+ *   never connects. There the strip is restored unfiltered, which is the
+ *   behaviour that existed before this reconciliation.
+ *
+ * `live === undefined` means "no answer", NOT "nothing is live" — the two must
+ * not collapse, or an old server would wipe the user's tabs on every open.
+ */
+export declare function restoreTabsAfterBoot(live: readonly string[] | undefined, options?: RestoreOpenTabsOptions): string[];
+export declare function restoreOpenTabsOnBoot(options?: RestoreOpenTabsOptions): string[];
+export declare const useSessionTabStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SessionTabState>>;
+/**
+ * Everything the tab strip and the tab map need about one slot, read straight
+ * from the lane registries. There is no separate per-tab mirror to drift.
+ */
+export declare function summarizeTab(sessionId: string, slot: number): TabSummary;
+/** Which slot a session sits in, or -1. Enforces the one-session-one-tab rule
+ *  at read time so callers cannot invent a second home for a session. */
+export declare function slotOf(sessionId: string): number;
+export { chatLane };
+//# sourceMappingURL=session-tab-store.d.ts.map

package/dist/stores/side-effect-store.d.ts

@@ -13,6 +13,14 @@ interface SideEffectState {
     setLoading: (loading: boolean) => void;
     clear: () => void;
 }
-export declare const useSideEffectStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SideEffectState>>;
+/**
+ * Side effects RECORDED BY ONE RUN — so, one conversation's.
+ *
+ * The list used to be global and the handler dropped anything that was not the
+ * tab in front, which meant a background tab's `side_effects.list` reply
+ * arrived and was thrown away: opening that tab showed an empty timeline for a
+ * run that had written files.
+ */
+export declare const useSideEffectStore: import("./session-scoped-store").SessionScopedStore<SideEffectState>;
 export {};
 //# sourceMappingURL=side-effect-store.d.ts.map

package/dist/stores/system-prompt-store.d.ts

@@ -0,0 +1,48 @@
+import type { WSSystemPromptInfo } from '../types/server-message';
+/**
+ * Identity-prompt size for this session: which variants exist, what each costs
+ * in tokens, which one is live, and whether the user has ever chosen.
+ *
+ * `chosen` drives the one behaviour that cannot be derived any other way: the
+ * first-run picker. The server materializes a default variant for every config,
+ * so `current === 'default'` says nothing about whether anyone picked it. The
+ * flag comes from the raw profile config file, where the key only exists once a
+ * selection has actually been made.
+ *
+ * `promptedThisSession` is local and deliberately not persisted: it stops the
+ * first-run picker from reopening on a reconnect or a re-render while still
+ * reopening on a genuinely new browser session, which is when the question is
+ * cheap to ask again.
+ */
+interface SystemPromptState {
+    info: WSSystemPromptInfo | null;
+    /**
+     * Live variant per tab. The catalogue (variants, token costs, `chosen`) is a
+     * project fact and is shared, but WHICH variant is live is a per-session
+     * preference: four tabs on one runtime each carry their own
+     * `systemPromptVariant`. Folding every `system_prompt.info` into one
+     * `info.current` made the picker show — and re-apply — a neighbour's choice.
+     */
+    currentBySession: Record<string, WSSystemPromptInfo['current']>;
+    /** Open state of the picker, and what opened it. */
+    pickerOpen: boolean;
+    /** True when the picker was opened by the New Session flow (confirm starts one). */
+    pickerStartsSession: boolean;
+    promptedThisSession: boolean;
+    setInfo: (info: WSSystemPromptInfo, sessionId?: string | undefined) => void;
+    /** Forget a closed tab's variant so the map cannot outlive its lane. */
+    dropSession: (sessionId: string) => void;
+    openPicker: (opts?: {
+        startsSession?: boolean;
+    }) => void;
+    closePicker: () => void;
+    markPrompted: () => void;
+}
+export declare const useSystemPromptStore: import("zustand").UseBoundStore<import("zustand").StoreApi<SystemPromptState>>;
+/**
+ * The variant live in a given tab, falling back to the last catalogue reply for
+ * hosts that answer unstamped.
+ */
+export declare function systemPromptCurrent(state: Pick<SystemPromptState, 'info' | 'currentBySession'>, sessionId: string | null | undefined): WSSystemPromptInfo['current'];
+export {};
+//# sourceMappingURL=system-prompt-store.d.ts.map

package/dist/stores/tool-stats-store.d.ts

@@ -0,0 +1,52 @@
+/** Leader-initiated calls when the wire payload carried no `agentName`. */
+export declare const LEADER_AGENT_KEY = "leader";
+export interface ToolStatsBucket {
+    started: number;
+    ok: number;
+    failed: number;
+    totalMs: number;
+}
+export interface ToolStatsDelegation extends ToolStatsBucket {
+    /** Tool calls reported inside delegated subagent runs. */
+    toolCalls: number;
+}
+export interface ToolStatsSession {
+    sessionId: string;
+    firstActivityAt: number;
+    lastActivityAt: number;
+    /** Keyed by tool name. */
+    perTool: Record<string, ToolStatsBucket>;
+    /** Keyed by `LEADER_AGENT_KEY` or the `agentName` from the wire payload. */
+    perAgent: Record<string, ToolStatsBucket>;
+    delegations: ToolStatsDelegation;
+}
+interface ToolStatsState {
+    sessions: Record<string, ToolStatsSession>;
+    recordToolStarted: (sessionId: string, call: {
+        name: string;
+        agentName?: string | undefined;
+    }) => void;
+    recordToolExecuted: (sessionId: string, call: {
+        name: string;
+        ok: boolean;
+        durationMs?: number | undefined;
+        agentName?: string | undefined;
+    }) => void;
+    recordDelegateStarted: (sessionId: string, delegation: {
+        target: string;
+    }) => void;
+    recordDelegateCompleted: (sessionId: string, delegation: {
+        target: string;
+        ok: boolean;
+        toolCalls?: number | undefined;
+    }) => void;
+    resetSession: (sessionId: string) => void;
+    clearAll: () => void;
+}
+export declare const useToolStatsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ToolStatsState>>;
+/** Completed-call success ratio for a bucket, or null when nothing completed. */
+export declare function bucketSuccessRatio(bucket: ToolStatsBucket): number | null;
+/** Calls started but not yet completed across a session (running right now). */
+export declare function sessionInFlight(session: ToolStatsSession): number;
+export {};
+//# sourceMappingURL=tool-stats-store.d.ts.map

package/dist/stores/types.d.ts

@@ -1,7 +1,22 @@
-import type { ContentBlock, Usage } from '@wrongstack/core/types';
-export interface MessageContent {
-    role: 'user' | 'assistant' | 'system' | 'tool';
-    content: string | ContentBlock[];
+import type { Usage } from '@wrongstack/core/types';
+export type CouncilVoteStatus = 'valid' | 'invalid' | 'failed' | 'cancelled';
+/** One council 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;
 }
 export interface ToolExecution {
     id: string;
@@ -113,6 +128,67 @@ export interface ChatMessage {
             auto?: boolean | undefined;
         }>;
     } | undefined;
+    /**
+     * Chimera review-report card payload — present when this system message
+     * renders as an actionable report card (ChimeraReportCard) instead of a
+     * plain notice bubble. The card carries the one-click "send the leader to
+     * work on this report" affordance; `actionedAt` flips once that prompt has
+     * been submitted so the button can never double-fire.
+     */
+    chimeraReport?: {
+        reportId: string;
+        actionable: boolean;
+        actionedAt: number | null;
+    } | undefined;
+    /**
+     * Council multi-model consensus & decision payload — present when this
+     * message renders as a dedicated, visually styled CouncilDecisionCard with
+     * voting charts and seat breakdowns instead of a plain text bubble.
+     */
+    councilDecision?: CouncilDecisionData | undefined;
+    /**
+     * Brain arbiter decision/intervention payload — present when this message
+     * renders as a dedicated, visually styled BrainDecisionCard with neural
+     * styling, risk level, and rationale instead of a plain text bubble.
+     */
+    brainDecision?: BrainDecisionData | undefined;
+}
+export interface CouncilDecisionData {
+    requestId?: string | undefined;
+    phase?: 'voting' | 'resolved' | undefined;
+    startedAt?: number | undefined;
+    resolvedAt?: number | undefined;
+    status?: string | undefined;
+    resolution?: string | undefined;
+    optionId?: string | undefined;
+    question?: string | undefined;
+    reason?: string | undefined;
+    configuredSeatCount?: number | undefined;
+    validVoteCount?: number | undefined;
+    distinctTargetCount?: number | undefined;
+    judgeUsed?: boolean | undefined;
+    judgeModel?: string | undefined;
+    judgeRationale?: string | undefined;
+    totalTokens?: number | undefined;
+    durationMs?: number | undefined;
+    warnings?: string[] | undefined;
+    seats: CouncilSeatVote[];
+}
+export interface BrainDecisionData {
+    id?: string | undefined;
+    kind: 'answered' | 'denied' | 'ask_human' | 'intervention' | 'check' | 'direct' | string;
+    intervened?: boolean | undefined;
+    decisionType?: string | undefined;
+    optionId?: string | undefined;
+    question?: string | undefined;
+    text?: string | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+    source?: string | undefined;
+    risk?: string | undefined;
+    tier?: string | undefined;
+    confidence?: number | undefined;
+    at?: number | undefined;
 }
 export interface SessionInfo {
     id: string;
@@ -150,6 +226,7 @@ export type AgentTranscriptKind = 'text' | 'thinking' | 'tool_use' | 'tool_resul
 export interface AgentTranscriptEntry {
     id: string;
     subagentId: string;
+    sessionId?: string | undefined;
     agentName: string;
     content: string;
     kind: AgentTranscriptKind;

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

@@ -1,16 +1,15 @@
+import type { ImageAttachment } from '../components/ChatInput/image-attachments.js';
 import type { QueuedItem, QueueMode } from './chat-store';
 import type { MailboxMessage } from './mailbox-store';
-import type { ImageAttachment } from '../components/ChatInput/image-attachments.js';
-export type Activity = 'chat' | 'agents' | 'files' | 'changes' | 'mailbox' | 'skills' | 'design' | 'worktrees' | 'officemap';
-/** Map any persisted (possibly legacy) activity value onto the current set. */
+export type Activity = 'chat' | 'agents' | 'files' | 'changes' | 'mailbox' | 'skills' | 'design';
+/** Map any persisted (possibly legacy) activity value onto the current set.
+ * 'worktrees' and 'officemap' were retired from the ActivityBar: worktree
+ * lanes now live as a tab inside the Changes panel, the fleet map as a tab
+ * inside the Agent Roster view. */
 export declare function coerceActivity(value: unknown): Activity;
 /** All valid currentView values. Kept in sync with the union on UIState. */
-declare const VIEWS: readonly ['chat', 'settings', 'memory', 'roster', 'context', 'goal', 'kanban', 'sddhub', 'files', 'changes', 'sessions', 'session-inspect', 'setup', 'skill', 'officemap', 'mailbox', 'debug', 'design-gallery', 'refresh-debug', 'analytics', 'codemap', 'techstack', 'chronicle', 'intake', 'deadcode', 'prompts'];
+declare const VIEWS: readonly ['chat', 'settings', 'memory', 'roster', 'context', 'goal', 'kanban', 'sddhub', 'files', 'changes', 'sessions', 'session-inspect', 'setup', 'skill', 'mailbox', 'debug', 'design-gallery', 'refresh-debug', 'analytics', 'codemap', 'techstack', 'chronicle', 'intake', 'deadcode', 'prompts', 'chimera'];
 type View = (typeof VIEWS)[number];
-/** Coerce an arbitrary value onto the current view union. Used by migrate
- *  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;
 /** Single source of truth for the secondary panel width bounds. */
 export declare const SIDEBAR_MIN_WIDTH = 240;
 export declare const SIDEBAR_MAX_WIDTH = 560;
@@ -26,6 +25,62 @@ export type WorkDashboardTab = 'todos' | 'tasks' | 'plan';
  * no observable surface at all.
  */
 export type InspectorTab = 'fleet' | 'agents' | 'sideEffects' | 'council';
+export type InspectorTarget = {
+    kind: 'fleet';
+    tab?: InspectorTab | undefined;
+} | {
+    kind: 'agent';
+    agentId: string;
+} | {
+    kind: 'sideEffects';
+} | {
+    kind: 'council';
+} | {
+    kind: 'task';
+    taskId: string;
+    boardId?: string | undefined;
+    title?: string | undefined;
+};
+interface SessionChromeState {
+    sidebarOpen: boolean;
+    activeActivity: Activity;
+    currentView: View;
+    inspectSessionId: string | null;
+    searchOpen: boolean;
+    searchQuery: string;
+    searchActiveMessageId: string | null;
+    scrollTarget: UIState['scrollTarget'];
+    modelSwitcherOpen: boolean;
+    promptLibraryOpen: boolean;
+    promptInsertRequest: string | null;
+    refinePanel: UIState['refinePanel'];
+    draftInput: string;
+    draftImages: ImageAttachment[];
+    processMonitorOpen: boolean;
+    queuePanelOpen: boolean;
+    cronJobsOpen: boolean;
+    sideContextBreakdownOpen: boolean;
+    terminalOpen: boolean;
+    dockSection: DockSection | null;
+    workDashboardTab: WorkDashboardTab;
+    inspectorOpen: boolean;
+    inspectorTab: InspectorTab;
+    inspectorTarget: InspectorTarget | null;
+    inspectorFocusedAgentId: string | null;
+    agentRosterActiveTab: 'live' | 'officemap' | 'catalog' | 'learning' | 'memory' | 'customize';
+    changesPanelTab: 'changes' | 'worktrees';
+    dockCustomizeOpen: boolean;
+    skillsState: UIState['skillsState'];
+    selectedMailMessage: MailboxMessage | null;
+    scrollPositions: Record<string, number>;
+    chatSwitcherOpen: boolean;
+    chatCheckpointOpen: boolean;
+    chatMemoryPanelOpen: boolean;
+    chatContextBreakdownOpen: boolean;
+    chatContextEditorOpen: boolean;
+    chatToolStatsOpen: boolean;
+    chatInputCollapsed: boolean;
+}
 interface UIState {
     sidebarOpen: boolean;
     /** Which activity icon is selected in the ActivityBar — controls secondary panel content. */
@@ -70,6 +125,10 @@ interface UIState {
     dockSection: DockSection | null;
     /** Active tab in the Work dock section. Mirrors TUI F5/F6 panel jumps. */
     workDashboardTab: WorkDashboardTab;
+    /** Which session the global dock/work projection currently describes. */
+    chromeSessionId: string | null;
+    /** Per-session screen projection, parked when switching tabs. */
+    chromeBySession: Record<string, SessionChromeState>;
     /** Dock chips the user has explicitly hidden via the customization menu.
      *  Empty = all chips visible (subject to each chip's own data condition).
      *  Mirrors the TUI's F12 status-line chip picker. */
@@ -84,6 +143,8 @@ interface UIState {
     inspectorOpen: boolean;
     /** Active tab inside the global right inspector drawer. */
     inspectorTab: InspectorTab;
+    /** Target routing descriptor for the universal inspector drawer. */
+    inspectorTarget: InspectorTarget | null;
     /** Agent ID to focus when opening the inspector on the agents tab. Cleared on read. */
     inspectorFocusedAgentId: string | null;
     /** Subagent whose full transcript currently replaces the main chat pane
@@ -91,6 +152,10 @@ interface UIState {
      *  persisted; ChatView auto-clears it when the focused agent leaves the
      *  fleet roster (removed, cleared, session stop). */
     subagentChatFocusId: string | null;
+    /** Which session the flat `subagentChatFocusId` describes. */
+    subagentChatFocusSessionId: string | null;
+    /** Per-tab subagent focus, so switching tabs restores what each was showing. */
+    subagentChatFocusBySession: Record<string, string | null>;
     /** Process Monitor overlay — triggered by /kill slash command. */
     processMonitorOpen: boolean;
     /** Queue Panel overlay — triggered by /queue slash command. */
@@ -103,6 +168,13 @@ interface UIState {
     terminalOpen: boolean;
     /** Monotonic signal consumed by TerminalPanel to create another PTY tab. */
     terminalCreateNonce: number;
+    agentRosterActiveTab: 'live' | 'officemap' | 'catalog' | 'learning' | 'memory' | 'customize';
+    setAgentRosterActiveTab: (tab: 'live' | 'officemap' | 'catalog' | 'learning' | 'memory' | 'customize') => void;
+    /** Active tab inside the Changes side panel. Worktree lanes moved from the
+     *  ActivityBar into this panel (kept in the store so shortcuts, slash
+     *  commands and the desktop bridge can deep-link to the Worktrees tab). */
+    changesPanelTab: 'changes' | 'worktrees';
+    setChangesPanelTab: (tab: 'changes' | 'worktrees') => void;
     /** Persisted Settings panel scroll position and active category tab so the user
      *  returns to the exact location after navigating away and back. */
     settingsActiveTab: string;
@@ -131,6 +203,20 @@ interface UIState {
     /** Context breakdown modal (triggered from side-panel session panel). */
     sideContextBreakdownOpen: boolean;
     setSideContextBreakdownOpen: (open: boolean) => void;
+    chatSwitcherOpen: boolean;
+    chatCheckpointOpen: boolean;
+    chatMemoryPanelOpen: boolean;
+    chatContextBreakdownOpen: boolean;
+    chatContextEditorOpen: boolean;
+    chatToolStatsOpen: boolean;
+    chatInputCollapsed: boolean;
+    setChatSwitcherOpen: (open: boolean) => void;
+    setChatCheckpointOpen: (open: boolean) => void;
+    setChatMemoryPanelOpen: (open: boolean) => void;
+    setChatContextBreakdownOpen: (open: boolean) => void;
+    setChatContextEditorOpen: (open: boolean) => void;
+    setChatToolStatsOpen: (open: boolean) => void;
+    setChatInputCollapsed: (collapsed: boolean) => void;
     /** Skills panel breadcrumb state — persisted so history survives panel switches. */
     skillsState: {
         /** The skill currently shown in the detail pane. */
@@ -206,6 +292,17 @@ interface UIState {
          *  enqueue path can forward them (mirrors the error/no-op paths in
          *  misc-handlers that pass refImages to enqueue). */
         images?: QueuedItem['images'];
+        /**
+         * The tab this refinement belongs to.
+         *
+         * The panel is a single global surface sitting above one shared composer,
+         * but the text in it was typed in ONE tab. Approving it — or letting the
+         * countdown expire — sends through the foreground facade, so with four
+         * tabs open an unstamped panel could deliver tab 1's prompt into tab 2's
+         * session, without the user touching anything. ChatInput takes the panel
+         * down when the foreground leaves the tab that opened it.
+         */
+        sessionId?: string | undefined;
     } | null;
     /** Prompt library modal (browse/search/insert prompts) open state. */
     promptLibraryOpen: boolean;
@@ -241,6 +338,7 @@ interface UIState {
     setRefinePanel: (panel: UIState['refinePanel']) => void;
     setDockSection: (section: DockSection | null) => void;
     setWorkDashboardTab: (tab: WorkDashboardTab) => void;
+    bindSessionChrome: (sessionId: string | null) => void;
     /** Click-a-chip semantics: same section again collapses the dock. */
     toggleDockSection: (section: DockSection) => void;
     /** Show/hide a dock chip from the customization menu. */
@@ -252,8 +350,12 @@ interface UIState {
     setAgentsMonitorOpen: (open: boolean) => void;
     setInspectorOpen: (open: boolean) => void;
     setInspectorTab: (tab: InspectorTab) => void;
+    openInspectorTarget: (target: InspectorTarget) => void;
+    closeInspector: () => void;
     setInspectorFocusedAgentId: (id: string | null) => void;
-    setSubagentChatFocus: (id: string | null) => void;
+    setSubagentChatFocus: (id: string | null, sessionId?: string | null) => void;
+    /** Forget a closed tab's subagent focus so a reused id cannot inherit it. */
+    forgetSession: (sessionId: string) => void;
     toggleInspector: () => void;
 }
 export declare const useUIStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<UIState>, "persist" | "setState"> & {
@@ -309,7 +411,7 @@ export declare const useUIStore: import("zustand").UseBoundStore<Omit<import("zu
                 /** Number of installed skills with a newer ref available than knownRefs. */
                 updateAvailableCount: number;
             };
-            currentView: "analytics" | "changes" | "chat" | "chronicle" | "codemap" | "context" | "deadcode" | "debug" | "design-gallery" | "files" | "goal" | "intake" | "kanban" | "mailbox" | "memory" | "officemap" | "prompts" | "refresh-debug" | "roster" | "sddhub" | "session-inspect" | "sessions" | "settings" | "setup" | "skill" | "techstack";
+            currentView: "analytics" | "changes" | "chat" | "chimera" | "chronicle" | "codemap" | "context" | "deadcode" | "debug" | "design-gallery" | "files" | "goal" | "intake" | "kanban" | "mailbox" | "memory" | "prompts" | "refresh-debug" | "roster" | "sddhub" | "session-inspect" | "sessions" | "settings" | "setup" | "skill" | "techstack";
             dockSection: DockSection | null;
             settingsActiveTab: string;
             scrollPositions: Record<string, number>;
@@ -368,7 +470,7 @@ export declare const useUIStore: import("zustand").UseBoundStore<Omit<import("zu
                 /** Number of installed skills with a newer ref available than knownRefs. */
                 updateAvailableCount: number;
             };
-            currentView: "analytics" | "changes" | "chat" | "chronicle" | "codemap" | "context" | "deadcode" | "debug" | "design-gallery" | "files" | "goal" | "intake" | "kanban" | "mailbox" | "memory" | "officemap" | "prompts" | "refresh-debug" | "roster" | "sddhub" | "session-inspect" | "sessions" | "settings" | "setup" | "skill" | "techstack";
+            currentView: "analytics" | "changes" | "chat" | "chimera" | "chronicle" | "codemap" | "context" | "deadcode" | "debug" | "design-gallery" | "files" | "goal" | "intake" | "kanban" | "mailbox" | "memory" | "prompts" | "refresh-debug" | "roster" | "sddhub" | "session-inspect" | "sessions" | "settings" | "setup" | "skill" | "techstack";
             dockSection: DockSection | null;
             settingsActiveTab: string;
             scrollPositions: Record<string, number>;