@wrongstack/tui 1.0.5 → 1.0.7

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

@@ -10,7 +10,7 @@ import type { BrainPanelSettings } from './brain-panel-model.js';
 import type { StatuslineItem } from './components/statusline-picker.js';
 import type { HistoryEntry } from './history-entry.js';
 import type { AuditLevel, CacheTtl, CompactorStrategy, ContextMode, LogLevel, ReasoningEffort, SettingsMode, SettingsPickerPatch, StatuslineMode, ToolResultViewMode } from './settings-contracts.js';
-import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, ResourceMenuAction, ResourceMenuSnapshot, ShadowState, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
+import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, ResourceMenuAction, ResourceMenuSnapshot, ShadowState, SubagentLaneView, SubagentRoleView, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
 export type Action = {
     type: 'addEntry';
     entry: DraftEntry;
@@ -170,6 +170,37 @@ export type Action = {
  | {
     type: 'modelPickerSearch';
     query: string;
+}
+/** ←/→ on the focused model row: cycle its reasoning-effort choice. */
+ | {
+    type: 'modelPickerEffort';
+    delta: number;
+}
+/** Per-session subagent model lanes — opened by `/subagent-models`. */
+ | {
+    type: 'subagentModelsOpen';
+    lanes: SubagentLaneView[];
+    roles: SubagentRoleView[];
+    enabled: boolean;
+    lock: boolean;
+    followSessionModel: boolean;
+    sessionTarget: string;
+} | {
+    type: 'subagentModelsClose';
+} | {
+    type: 'subagentModelsMove';
+    delta: number;
+} | {
+    type: 'subagentModelsUpdate';
+    lanes: SubagentLaneView[];
+    roles: SubagentRoleView[];
+    enabled: boolean;
+    lock: boolean;
+    followSessionModel: boolean;
+    sessionTarget: string;
+} | {
+    type: 'subagentModelsHint';
+    text?: string | undefined;
 } | {
     type: 'autonomyPickerOpen';
     options: AutonomyOption[];
@@ -304,9 +335,15 @@ export type Action = {
  * Advance the progress block. Every field is optional so the same action
  * serves the spinner ticker (nothing but a frame bump), the byte-progress
  * sink, and the host's stage reports.
+ *
+ * `sessionId` attributes the tick to its runResume chain: after a
+ * cross-path start is rejected, the SUPERSEDED chain keeps ticking with the
+ * other session's byte counts, and the reducer drops those instead of
+ * mutating the winning load. Unstamped ticks keep legacy semantics.
  */
  | {
     type: 'resumeLoadTick';
+    sessionId?: string | undefined;
     loadedBytes?: number | undefined;
     totalBytes?: number | undefined;
     /** Human-readable stage line to push onto the rolling log. */
@@ -321,15 +358,28 @@ export type Action = {
  */
  | {
     type: 'resumeStreamChunk';
+    /**
+     * Session the chunk belongs to. Stamped by the runResume chain so the
+     * reducer can drop a SUPERSEDED run's terminating `done` chunk instead
+     * of settling the winning load with another session's transcript.
+     * Unstamped chunks keep legacy semantics.
+     */
+    sessionId?: string | undefined;
     entries: HistoryEntry[];
     /** Total entries in the replay, for the batch counter. */
     total: number;
     done?: boolean | undefined;
     contextSnapshot?: ContextSnapshot | undefined;
 }
-/** Abandon an in-flight resume (failure, or a second resume superseding it). */
+/**
+ * Abandon an in-flight resume (failure, or a second resume superseding it).
+ * `sessionId` attributes the abort to its runResume chain: a SUPERSEDED
+ * chain's abort must not cancel the winning load. Unstamped aborts keep
+ * legacy semantics.
+ */
  | {
     type: 'resumeLoadAbort';
+    sessionId?: string | undefined;
 }
 /** Replace all history entries with the given hydrated entries from a resumed session. */
  | {

package/dist/app-props.d.ts

@@ -279,6 +279,13 @@ export interface AppProps {
     onBrainRiskLevel?: ((level: BrainRiskLevel) => string | undefined) | undefined;
     /** Full Brain settings editor bridge (live apply + persist). */
     brainPanelHost?: import('./brain-panel-model.js').BrainPanelHost | undefined;
+    /**
+     * Session-scoped subagent model plan bridge for `/subagent-models`. The host
+     * owns the plan (it needs the session writer to journal it); the panel only
+     * reads snapshots and calls back. Absent = the panel stays unavailable and
+     * the slash command falls back to its text output.
+     */
+    subagentModelsHost?: import('./subagent-models-panel-model.js').SubagentModelsPanelHost | undefined;
     /** Get current Shadow Agent state. */
     getShadowData?: (() => {
         activeId: string | null;

package/dist/app-state.d.ts

@@ -10,7 +10,7 @@ import type { HistoryEntry } from './history-entry.js';
 import type { TuiHistoryBudget } from './history-retention.js';
 import type { ResumeLoadState } from './resume-load.js';
 import type { AuditLevel, CacheTtl, CompactorStrategy, ContextMode, LogLevel, ReasoningEffort, SettingsMode, StatuslineMode, ToolResultViewMode } from './settings-contracts.js';
-import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PanelPositionMap, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, RefineFailureDecision, RefineFailureModel, ResourceMenuAction, ResourceMenuSnapshot, SendMode, ShadowState, StatuslineItem, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
+import type { AutonomyOption, ChipMeta, HelpEntry, LiveSessionEntry, McpPickerItem, ModeOption, PanelPositionMap, PluginPickerItem, ProjectPickerItem, PromptPickEntry, ProviderOption, RefineFailureDecision, RefineFailureModel, ResourceMenuAction, ResourceMenuSnapshot, SendMode, ShadowState, StatuslineItem, SubagentLaneView, SubagentRoleView, ToolPickerItem, WorktreeRow } from './ui-contracts.js';
 export type { Settings } from './app-settings-type.js';
 export type { DraftEntry, GoalSummary, QueueItem, ResumeSessionEntry, SlashCommandMatch, } from './app-state-core-types.js';
 export type { FleetEntry } from './app-state-fleet.js';
@@ -202,6 +202,12 @@ export type State = {
         hint?: string | undefined;
         /** Live search filter in step 2. */
         searchQuery: string;
+        /**
+         * Reasoning effort chosen for the FOCUSED model with ←/→. `'default'`
+         * (the sentinel every navigation resets to) means "leave the persisted
+         * effort alone", which is what Enter did before the strip existed.
+         */
+        effort: string;
         /**
          * 'switch' — Enter switches the SESSION model (the /model command).
          * 'pick'   — generic reusable selection: Enter just RETURNS the choice
@@ -504,6 +510,23 @@ export type State = {
         shadow: ShadowState;
         hint?: string | undefined;
     };
+    /**
+     * Per-session subagent model lanes — opened by `/subagent-models`. Rows are
+     * pre-rendered view strings: the hook owns the mapping from the core plan so
+     * the reducer never reaches into coordination types.
+     */
+    subagentModels: {
+        open: boolean;
+        lanes: SubagentLaneView[];
+        roles: SubagentRoleView[];
+        selected: number;
+        enabled: boolean;
+        lock: boolean;
+        followSessionModel: boolean;
+        /** The session's own provider/model, shown as that switch's target. */
+        sessionTarget: string;
+        hint?: string | undefined;
+    };
     /** Interactive API-key / OAuth manager — opened by `/auth`. */
     authPanel: AuthPanelState;
     /** Project switcher panel — opened by F1 or `/project`. */

package/dist/components/model-picker-effort.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Per-model reasoning-effort strip for the `/model` picker.
+ *
+ * Step 2 focuses one model at a time; ←/→ on that row picks the reasoning
+ * effort the session should run it at. The vocabulary is MODEL-AWARE, exactly
+ * like settings field 24 (`reasoners` cycle in reducers/settings-values.ts):
+ * a model that documents its effort levels offers only those, an undocumented
+ * reasoner offers the full canonical set (the runtime resolver drops what the
+ * wire adapter cannot carry), and a non-reasoning model offers nothing at all.
+ *
+ * The list is always led by {@link EFFORT_KEEP} — "don't touch the configured
+ * effort" — so opening the picker and pressing Enter keeps the exact behaviour
+ * it had before the strip existed.
+ */
+import type { ReasoningEffort } from '../settings-contracts.js';
+/** Sentinel first option: leave the persisted reasoning effort untouched. */
+export declare const EFFORT_KEEP = "default";
+export type ModelEffortChoice = typeof EFFORT_KEEP | ReasoningEffort;
+/** Only the fields of `ProviderOption.modelDetails[id]` this module reads. */
+export interface EffortModelDetail {
+    reasoning?: boolean | undefined;
+    effortLevels?: readonly string[] | undefined;
+}
+/**
+ * Effort choices for one model, canonical order (weakest → strongest),
+ * always led by `default`. Empty when the model does not reason — callers
+ * treat an empty list as "no strip, arrows are inert".
+ */
+export declare function modelEffortOptions(detail: EffortModelDetail | undefined): readonly ModelEffortChoice[];
+/** Detail lookup for the focused model — the shape both reducer and view need. */
+export declare function effortOptionsForFocused(picker: {
+    step: 'provider' | 'model';
+    providerOptions: ReadonlyArray<{
+        id: string;
+        modelDetails?: Record<string, EffortModelDetail> | undefined;
+    }>;
+    filteredOptions: readonly string[];
+    selected: number;
+    pickedProviderId?: string | undefined;
+    purpose?: 'switch' | 'pick';
+}): readonly ModelEffortChoice[];
+/** Cycle the current choice by `delta`, clamped to the wrap-around list. */
+export declare function cycleEffort(options: readonly ModelEffortChoice[], current: string, delta: number): ModelEffortChoice;
+//# sourceMappingURL=model-picker-effort.d.ts.map

package/dist/components/model-picker.d.ts

@@ -1,4 +1,5 @@
 import type React from 'react';
+import { type ModelEffortChoice } from './model-picker-effort.js';
 export interface ProviderOption {
     id: string;
     family: string;
@@ -12,6 +13,13 @@ export interface ProviderOption {
         tools?: boolean | undefined;
         vision?: boolean | undefined;
         reasoning?: boolean | undefined;
+        /**
+         * Effort vocabulary this model documents (models.dev
+         * `reasoning_options`). Drives the ←/→ effort strip in step 2;
+         * absent/empty on a model whose levels are undocumented, which the
+         * strip reads as "offer the full canonical set".
+         */
+        effortLevels?: readonly string[] | undefined;
         maxContext?: number | undefined;
         maxOutput?: number | undefined;
         inputCost?: number | undefined;
@@ -41,6 +49,14 @@ interface ModelPickerProps {
     titleLabel?: string | undefined;
     columns?: number | undefined;
     maxRows?: number | undefined;
+    /**
+     * Effort choices for the focused model, led by `default`. Empty when the
+     * model does not reason (or in 'pick' purpose) — the strip is then hidden
+     * and ←/→ are inert.
+     */
+    effortOptions?: readonly ModelEffortChoice[] | undefined;
+    /** Currently highlighted entry of {@link effortOptions}. */
+    effortChoice?: string | undefined;
 }
 /**
  * Two-step Ink overlay for the TUI's `/model` command.
@@ -49,6 +65,6 @@ interface ModelPickerProps {
  *
  * Driven entirely by props — App owns cursor state, key events, and search.
  */
-export declare function ModelPicker({ step, providerOptions, filteredOptions, selected, pickedProviderId, searchQuery, hint, titleLabel, columns, maxRows, }: ModelPickerProps): React.ReactElement;
+export declare function ModelPicker({ step, providerOptions, filteredOptions, selected, pickedProviderId, searchQuery, hint, titleLabel, columns, maxRows, effortOptions, effortChoice, }: ModelPickerProps): React.ReactElement;
 export {};
 //# sourceMappingURL=model-picker.d.ts.map

package/dist/components/subagent-models-panel.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+import type { SubagentLaneView, SubagentRoleView } from '../ui-contracts.js';
+/**
+ * Per-session subagent model lanes — the panel behind `/subagent-models`.
+ *
+ * One row per lane: the Nth subagent running at any moment takes the Nth free
+ * lane, so a fan-out of 8 workers runs on 8 different provider/model pairs.
+ * Editing a row reuses the shared two-step model picker (`requestModelPick`),
+ * which is why this component carries no provider list of its own.
+ */
+export interface SubagentModelsPanelProps {
+    lanes: SubagentLaneView[];
+    roles: SubagentRoleView[];
+    selected: number;
+    enabled: boolean;
+    lock: boolean;
+    followSessionModel: boolean;
+    sessionTarget: string;
+    hint?: string | undefined;
+    maxRows?: number | undefined;
+}
+export declare function SubagentModelsPanel({ lanes, roles, selected, enabled, lock, followSessionModel, sessionTarget, hint, maxRows, }: SubagentModelsPanelProps): React.ReactElement;
+//# sourceMappingURL=subagent-models-panel.d.ts.map

package/dist/components/user-input-prompt.d.ts

@@ -0,0 +1,29 @@
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { UserInputQuestion, UserInputRequest, UserInputResponse } from '@wrongstack/core/types';
+import type React from 'react';
+import { type DOMElement } from '../ink.js';
+export type PendingUserInput = {
+    request: UserInputRequest;
+    resolve: (response: UserInputResponse) => void;
+};
+type AnswerDraft = {
+    selected: string[];
+    text: string;
+    customSelected: boolean;
+    delegated: boolean;
+};
+type Draft = Record<string, AnswerDraft>;
+export declare function usePendingUserInput(events: EventBus): PendingUserInput | null;
+export declare function UserInputPrompt({ pending }: {
+    pending: PendingUserInput;
+}): React.ReactElement;
+export declare function initialDraft(request: UserInputRequest): Draft;
+export declare function validateDraft(questions: UserInputQuestion[], draft: Draft): {
+    valid: boolean;
+    missingCount: number;
+    firstMissing?: UserInputQuestion | undefined;
+};
+/** Match one-based SGR mouse cells against Ink's measured zero-based rectangle. */
+export declare function pointInsideElement(element: DOMElement | null, x: number, y: number): boolean;
+export {};
+//# sourceMappingURL=user-input-prompt.d.ts.map

package/dist/hooks/use-app-panels-state.d.ts

@@ -8,6 +8,7 @@ import { useModePicker } from './use-mode-picker.js';
 import { useModelPickRequest } from './use-model-pick.js';
 import { useShadowPanel } from './use-shadow-panel.js';
 import { useStatuslineHiddenSync } from './use-statusline-hidden-sync.js';
+import { useSubagentModelsPanel } from './use-subagent-models-panel.js';
 /**
  * Every field below is forwarded verbatim to one of the panel hooks, so the
  * types come from those hooks instead of `any`. AppProps already carries the
@@ -31,6 +32,7 @@ export declare function useAppPanelsState(params: {
      * guard, so an omitted registry threw the moment the help panel opened.
      * The previous `as any` at the call site hid exactly that.
      */
+    subagentModelsHost?: Parameters<typeof useSubagentModelsPanel>[0]['subagentModelsHost'];
     slashRegistry: AppProps['slashRegistry'];
     hiddenItems: Parameters<typeof useStatuslineHiddenSync>[0]['hiddenItems'];
     setHiddenItems: Parameters<typeof useStatuslineHiddenSync>[0]['setHiddenItems'];
@@ -47,6 +49,7 @@ export declare function useAppPanelsState(params: {
     openShadowPanel: () => void;
     handleShadowStart: () => Promise<void>;
     handleShadowStop: () => Promise<void>;
+    subagentModelsCtl: import("./use-subagent-models-panel.js").SubagentModelsPanelController;
     openHelpPanel: () => void;
 };
 //# sourceMappingURL=use-app-panels-state.d.ts.map

package/dist/hooks/use-app-picker-keys.d.ts

@@ -29,11 +29,13 @@ interface UseAppPickerKeysOptions {
     handleModelPicked: ModelPickRequestController['handleModelPicked'];
     handleShadowStart: () => Promise<void>;
     handleShadowStop: () => Promise<void>;
+    /** `/subagent-models` panel controller; absent when the host wires no plan. */
+    subagentModelsController?: import('./use-subagent-models-panel.js').SubagentModelsPanelController | undefined;
     statuslineHiddenForPicker: () => StatuslineItem[];
     onPickerEnter: () => Promise<void>;
     onThemePickerEnter?: () => void;
     setPromptFavorite: (slug: string, favorite: boolean) => Promise<void>;
 }
-export declare function useAppPickerKeys({ host, state, dispatch, environment, statusbar, panelControllers, authPanelController, brainController, lastEnterAtRef, inputGateRef, submitRef, promptUsageRef, setDraft, acceptSlashPickerSelection, changeBrainRisk, handleModelPicked, handleShadowStart, handleShadowStop, statuslineHiddenForPicker, onPickerEnter, onThemePickerEnter, setPromptFavorite, }: UseAppPickerKeysOptions): (input: string, key: import("../components/input.js").KeyEvent, isEnter: boolean) => boolean;
+export declare function useAppPickerKeys({ host, state, dispatch, environment, statusbar, panelControllers, authPanelController, brainController, lastEnterAtRef, inputGateRef, submitRef, promptUsageRef, setDraft, acceptSlashPickerSelection, changeBrainRisk, handleModelPicked, handleShadowStart, handleShadowStop, subagentModelsController, statuslineHiddenForPicker, onPickerEnter, onThemePickerEnter, setPromptFavorite, }: UseAppPickerKeysOptions): (input: string, key: import("../components/input.js").KeyEvent, isEnter: boolean) => boolean;
 export {};
 //# sourceMappingURL=use-app-picker-keys.d.ts.map

package/dist/hooks/use-panel-controllers.d.ts

@@ -15,6 +15,8 @@ interface PanelControllersOptions {
     openModePicker: () => void | Promise<void>;
     openBrainPanel: () => void | Promise<void>;
     openShadowPanel: () => void | Promise<void>;
+    /** Opens the `/subagent-models` lane panel; omitted when the host wires no plan. */
+    openSubagentModelsPanel?: (() => void) | undefined;
     openHelpPanel: () => void | Promise<void>;
     getSettings: AppProps['getSettings'];
     getPluginItems: AppProps['getPluginItems'];
@@ -29,7 +31,7 @@ interface PanelControllersOptions {
     getActiveModelReasoningEffortLevels?: AppProps['getActiveModelReasoningEffortLevels'];
 }
 /** Owns panel openers and extension picker refresh/toggle controllers. */
-export declare function usePanelControllers({ state, stateRef, dispatch, getPickableProviders, getProjectPickerItems, getLiveSessions, onPanelOpen, openStatuslinePicker, openAuthPanel, openModePicker, openBrainPanel, openShadowPanel, openHelpPanel, getSettings, getPluginItems, onPluginToggle, getMcpServers, onMcpToggle, onMcpRestart, getToolsItems, onToolToggle, setLiveToolCount, getActiveModelReasoningEffortLevels, }: PanelControllersOptions): {
+export declare function usePanelControllers({ state, stateRef, dispatch, getPickableProviders, getProjectPickerItems, getLiveSessions, onPanelOpen, openStatuslinePicker, openAuthPanel, openModePicker, openBrainPanel, openShadowPanel, openSubagentModelsPanel, openHelpPanel, getSettings, getPluginItems, onPluginToggle, getMcpServers, onMcpToggle, onMcpRestart, getToolsItems, onToolToggle, setLiveToolCount, getActiveModelReasoningEffortLevels, }: PanelControllersOptions): {
     openModelPicker: () => Promise<void>;
     openProjectPicker: () => Promise<void>;
     openFKeyPicker: () => void;

package/dist/hooks/use-picker-keys-types.d.ts

@@ -1,6 +1,7 @@
 import type React from 'react';
 import type { Action, State } from '../app-reducer.js';
 import type { BrainPanelRow } from '../brain-panel-model.js';
+import type { ReasoningEffort } from '../settings-contracts.js';
 import type { AutonomyStage } from './use-statusline-state.js';
 export interface PickerKeysHost {
     state: State;
@@ -20,6 +21,12 @@ export interface PickerKeysHost {
     currentContextTokens: number;
     currentProvider: string | undefined;
     currentModel: string | undefined;
+    /**
+     * Persist the reasoning effort chosen on the /model picker's effort strip.
+     * Returns an error string (or a promise of one) on failure, null on success
+     * — same contract as `saveSettings`, which is what the app wiring forwards to.
+     */
+    saveReasoningEffort: ((effort: ReasoningEffort) => string | null | Promise<string | null>) | undefined;
     switchAutonomy: ((mode: AutonomyStage) => string | null) | undefined;
     submit: ((text: string) => void) | undefined;
     onAuthEnter: (() => void) | undefined;
@@ -51,6 +58,12 @@ export interface PickerKeysHost {
     onModelPicked: ((providerId: string, modelId: string) => void) | undefined;
     onShadowStart: (() => Promise<void> | void) | undefined;
     onShadowStop: (() => Promise<void> | void) | undefined;
+    /** `/subagent-models` panel: edit the focused lane through the shared picker. */
+    onSubagentLaneEdit: ((index: number) => void) | undefined;
+    /** `/subagent-models` panel: clear the focused lane. */
+    onSubagentLaneClear: ((index: number) => void) | undefined;
+    /** `/subagent-models` panel: toggle `lock` (lanes vs leader) or `enabled`. */
+    onSubagentPlanToggle: ((field: 'lock' | 'enabled' | 'followSessionModel') => void) | undefined;
     onFKeyPickerEnter: (() => void) | undefined;
     onPickerEnter: (() => Promise<void>) | undefined;
     /**

package/dist/hooks/use-subagent-models-panel.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `/subagent-models` panel controller.
+ *
+ * Opens the panel from a host snapshot, and edits a lane through the SAME
+ * two-step provider→model overlay the `/model` command uses (`requestModelPick`
+ * in purpose 'pick'), so there is exactly one model-selection UI in the TUI.
+ */
+import React from 'react';
+import type { Action } from '../app-action-type.js';
+import type { SubagentModelsPanelHost } from '../subagent-models-panel-model.js';
+import type { ModelPickSelection } from './use-model-pick.js';
+interface UseSubagentModelsPanelOptions {
+    dispatch: React.Dispatch<Action>;
+    subagentModelsHost?: SubagentModelsPanelHost | undefined;
+    /** Shared model overlay; absent when the host exposes no provider list. */
+    requestModelPick?: ((title: string) => Promise<ModelPickSelection>) | undefined;
+}
+export interface SubagentModelsPanelController {
+    openSubagentModelsPanel: () => void;
+    onSubagentLaneEdit: (index: number) => void;
+    onSubagentLaneClear: (index: number) => void;
+    onSubagentPlanToggle: (field: 'lock' | 'enabled' | 'followSessionModel') => void;
+}
+export declare function useSubagentModelsPanel(opts: UseSubagentModelsPanelOptions): SubagentModelsPanelController;
+export {};
+//# sourceMappingURL=use-subagent-models-panel.d.ts.map

package/dist/index.d.ts

@@ -10,5 +10,6 @@ export { parseNextSteps } from './components/suggestions.js';
 export { parseInline } from './markdown.js';
 export type { RunTuiOptions } from './run-tui.js';
 export { runTui } from './run-tui.js';
+export type { SubagentLaneTarget, SubagentModelsPanelHost, SubagentModelsSnapshot, } from './subagent-models-panel-model.js';
 export type { ResourceMenuAction, ResourceMenuDetail, ResourceMenuId, ResourceMenuItem, ResourceMenuSnapshot, } from './ui-contracts.js';
 //# sourceMappingURL=index.d.ts.map