dsh-code 1.3.0 → 1.4.0

package/lib/types/app.d.ts

@@ -14,42 +14,34 @@
  * @module @deepseek-ai/dsh-code/app
  */
 import { type ReactElement } from 'react';
-import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
 import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
 import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
 import { type ThemeName } from './theme.ts';
 import { type LanguageName } from './i18n.ts';
 import type { LauncherUpdateStatus } from './update.ts';
-import type { TranscriptStore } from './store.ts';
+import type { TranscriptStore } from './session/store.ts';
 import { type TranscriptEntry } from './render/projection.ts';
+import { type SubagentAttachmentServices } from './session/attach.ts';
 import type { ApprovalStore } from './approval.ts';
-import { type CommandsView } from './commands.ts';
+import type { CommandsView } from './commands.ts';
 import type { ModelDirectory, ModelRow } from './models.ts';
 import { type DiscoveredModelView, type ProviderConfiguration, type ProviderSettingsDirectory, type ProviderTargetView } from './provider-settings.ts';
 import type { QuestionStore } from './questions.ts';
-import type { SkillsView, SkillRow } from './skills.ts';
-import { type MentionCandidate } from './mentions.ts';
-import type { SubagentFeedView } from './subagents.ts';
+import type { SkillsView } from './skills.ts';
+import type { MentionCandidate } from './mentions.ts';
+import type { SubagentFeedView } from './session/subagents.ts';
 import type { UsageView } from './render/usage.ts';
-import { type JobRow, type SearchRow } from './kernel-panels.ts';
+import { type JobRow, type SearchRow } from './panels/kernel-panels.ts';
 import type { PresetRow } from './presets.ts';
 import type { PermissionRow } from './permissions.ts';
 import type { PluginRow } from './plugin-inventory.ts';
-import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
-import { type GitDiffView, type ReviewBranch, type ReviewCommit, type ReviewSelection } from './git-workflow.ts';
-import { type ProviderAuthorizationDirectory, type ProviderAuthorizationRow } from './authorization.ts';
-import { type FilePathInspection, type ImagePathInspection } from './attachments.ts';
-/** Visual priority for one bounded local notice. */
-export type NoticeTone = 'info' | 'warning' | 'error';
-/** One mutation the terminal may request for a pending next-turn inbox item. */
-export type QueueMutation = {
-    readonly kind: 'remove';
-} | {
-    readonly kind: 'edit';
-    readonly text: string;
-} | {
-    readonly kind: 'steer';
-};
+import type { SessionDirectoryOptions, SessionRow } from './session/session-directory.ts';
+import type { GitDiffView, ReviewBranch, ReviewCommit, ReviewSelection } from './git-workflow.ts';
+import type { ProviderAuthorizationDirectory, ProviderAuthorizationRow } from './authorization.ts';
+import type { FilePathInspection, ImagePathInspection } from './attachments.ts';
+export { completionCandidates, stepCompletionIndex } from './completion.ts';
+import type { NoticeTone, QueueMutation } from './ui/ui-contract.ts';
+export type { NoticeTone, QueueMutation } from './ui/ui-contract.ts';
 /** Props the runner hands the app; callbacks stay owned by the runner. */
 export interface AppProps {
     /** Event-fed transcript store for the live session. */
@@ -132,6 +124,8 @@ export interface AppProps {
     subscribeModelProviders?: (listener: () => void) => () => void;
     /** Store or rotate one provider credential through the Harness credential service. */
     saveModelProviderCredential?: (target: ProviderTargetView, key: string) => Promise<void>;
+    /** Switch a provider route to its subscription channel (drops the key reference). */
+    enableModelProviderSubscription?: (target: ProviderTargetView) => Promise<void>;
     /** Remove one writable provider credential without removing its settings profile. */
     unsetModelProviderCredential?: (target: ProviderTargetView) => Promise<void>;
     /** Remove one user-owned provider profile and its page-managed credential. */
@@ -195,6 +189,8 @@ export interface AppProps {
     searchSessions?: (query: string, signal?: AbortSignal) => Promise<readonly SearchRow[]>;
     /** Load this session's subagent conversations (children by lineage). */
     loadSubagents: () => Promise<readonly SessionRow[]>;
+    /** Live subagent attachment: seed + the two real-time buses, runner-wired. */
+    attachSubagent?: SubagentAttachmentServices;
     switchSession: (row: SessionRow) => void;
     cancelSessionSwitch: () => boolean;
     loadPlugins: () => readonly PluginRow[];
@@ -252,34 +248,6 @@ export declare function streamTailBodyColumns(rowColumns: number, prefix: string
 export declare function queuedInboxRows(entries: readonly TranscriptEntry[], ids: readonly string[]): readonly Extract<TranscriptEntry, {
     kind: 'pending';
 }>[];
-/** One completion candidate row. */
-interface CompletionCandidate {
-    /** Insertion text for the command name (with leading slash). */
-    label: string;
-    /** Human-readable description shown beside the label. */
-    description: string;
-    /** Candidate origin; skills land the same literal text but route through the prompt. */
-    origin: 'command' | 'skill' | 'mention';
-}
-/**
- * Wrap one completion-menu cursor step. An empty menu keeps the index at 0:
- * `% 0` is NaN, and a NaN index silently disables the highlight, the accept
- * key, and any later Enter that runs through the menu.
- */
-export declare function stepCompletionIndex(index: number, delta: number, count: number): number;
-/**
- * Resolve completion candidates for the current input: TUI-local commands,
- * the live registry descriptors, and user-invocable skills, filtered by the
- * typed prefix. Command names win collisions (the dispatch tries the
- * registry first and only then falls through to the skill gesture), and a
- * later duplicate name never renders twice.
- *
- * A bare `/` returns the FULL merged list — Codex's command popup shows every
- * command inside a scroll window on an empty filter, and the menu's own
- * selection window bounds the visible rows, so no slice cap is needed.
- */
-export declare function completionCandidates(value: string, descriptors: readonly CommandDescriptor[], skills: readonly SkillRow[]): readonly CompletionCandidate[];
-/** One cached settled row: the row Box plus its roomy-prompt spacers. */
 interface SettledRowRecord {
     /** The row Box element (keyed by the entry's settled index). */
     box: ReactElement;
@@ -365,4 +333,3 @@ interface SettledRowsResult {
 export declare function computeSettledRows(previous: SettledRowsCache | undefined, entries: readonly TranscriptEntry[], settled: number, showReasoning: boolean, resumed: boolean, epoch: number, columns?: number, rowCap?: number): SettledRowsResult;
 /** The whole terminal app; state arrives via the store, output via Ink. */
 export declare function App(props: AppProps): ReactElement;
-export {};

package/lib/types/completion.d.ts

@@ -0,0 +1,29 @@
+/** Slash-command parsing and completion candidates shared by the composer and help panel. */
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+import { type MessageKey } from './i18n.ts';
+import type { SkillRow } from './skills.ts';
+/** One TUI-owned slash command: label plus its i18n description key. */
+export interface LocalCommand {
+    readonly label: string;
+    readonly descriptionKey: MessageKey;
+}
+/** One source of truth for TUI-owned slash commands in completion and `/help`. */
+export declare const LOCAL_COMMANDS: readonly LocalCommand[];
+export declare const LOCAL_COMMAND_NAMES: ReadonlySet<string>;
+/** TUI-local commands that reject trailing input instead of forwarding it as a prompt. */
+export declare const BARE_LOCAL_COMMANDS: ReadonlySet<string>;
+/** Split a slash line into the command name and any trailing input. */
+export declare function slashNameAndArgs(text: string): {
+    readonly name: string;
+    readonly args: string;
+} | undefined;
+/** One completion candidate row. */
+export interface CompletionCandidate {
+    readonly label: string;
+    readonly description: string;
+    readonly origin: 'command' | 'skill' | 'mention';
+}
+/** Wrap one completion-menu cursor step; an empty menu keeps the index at zero. */
+export declare function stepCompletionIndex(index: number, delta: number, count: number): number;
+/** Merge local commands, registry descriptors, and skills using dispatch shadowing order. */
+export declare function completionCandidates(value: string, descriptors: readonly CommandDescriptor[], skills: readonly SkillRow[]): readonly CompletionCandidate[];

package/lib/types/composer.d.ts

@@ -0,0 +1,150 @@
+/** Composer input, command routing, attachments, and one-shot composer animations. */
+import { type ReactElement } from 'react';
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
+import { type FilePathInspection, type ImagePathInspection } from './attachments.ts';
+import type { SkillRow } from './skills.ts';
+import { type MentionCandidate } from './mentions.ts';
+import { type ReviewSelection } from './git-workflow.ts';
+import { type LanguageName } from './i18n.ts';
+import { type DeepseekWaveStyle, type DeepseekWaveTier } from './render/animations.ts';
+import type { TranscriptEntry } from './render/projection.ts';
+import type { NoticeTone, QueueMutation } from './ui/ui-contract.ts';
+/**
+ * The prompt box: TUI-local slash commands handled locally, other lines
+ * dispatched; input editing keeps a cursor with history and completion.
+ * While a modal (approval / question / model panel) owns the keys, the
+ * box passes every key through untouched.
+ */
+export declare function Composer({ active, frozen, frozenHint, busy, descriptors, skills, dispatch, steer, submitMode, cycleSubmitMode, interrupt, quit, openModel, openEffort, openHelp, openMode, openPermission, openResume, openSearch, openPlugin, openUpdate, openSchedule, openJobs, openStatusline, openTheme, openLanguage, saveLanguage, openHistory, openQueue, openAgents, openSubagent, openTodos, openUsage, openDelete, openDiff, openReviewPicker, reviewChanges, deleteConfirm, confirmDelete, cancelDelete, createSession, forkSession, cancelSessionSwitch, notify, applyEditorKeys, hasNotice, dismissNotice, toggleReasoning, openVerbose, clearView, refresh, loadMentions, inspectImages, prepareImages, inspectFiles, prepareFiles, cycleMode, exportTranscript, renameTitle, copyLastResponse, recallSpace, recordLocal, recordHistory, queued, updateQueued, historyFill, historyConsumed, animations, applyAnimations, applyRainbow, rainbowBurstId, waveTier, waveStyle, maxRows, anchorRowsBelow, tabTitle, onEditorRows, onMenuRows, sessionKey }: {
+    active: boolean;
+    frozen: boolean;
+    /** Frozen-band hint naming the surface that owns the keyboard; an empty
+     * draft otherwise advertises typing that the composer cannot accept. */
+    frozenHint?: string;
+    busy: boolean;
+    descriptors: readonly CommandDescriptor[];
+    skills: readonly SkillRow[];
+    dispatch: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void;
+    /** Submit as steering into the running turn (see {@link AppProps.steer}). */
+    steer: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void;
+    /** Delivery mode the next submission uses; Tab on an empty composer flips it. */
+    submitMode: 'queue' | 'steer';
+    /** Flip {@link submitMode} and report the new mode. */
+    cycleSubmitMode: () => void;
+    /** The full current session identity ('' while pending); the delivery origin. */
+    sessionKey: string;
+    interrupt: () => boolean;
+    quit: () => void;
+    openModel: () => void;
+    openEffort: () => void;
+    openHelp: () => void;
+    openMode: () => void;
+    openPermission: () => void;
+    openResume: () => void;
+    /** Open the /search panel with an optional seed query. */
+    openSearch: (query: string) => void;
+    openPlugin: (query?: string) => void;
+    /** Open the /update panel (aligned upgrade surface). */
+    openUpdate: () => void;
+    /** Open the /schedule reminder panel (read-only catalog). */
+    openSchedule: () => void;
+    openJobs: () => void;
+    openStatusline: () => void;
+    openTheme: () => void;
+    /** Open the /language picker (bare /language). */
+    openLanguage: () => void;
+    /** Apply and persist a language chosen by argument. */
+    saveLanguage: (name: LanguageName) => void;
+    openHistory: () => void;
+    openQueue: () => void;
+    /** Open the /agents panel (live subagent feed + transcript entry). */
+    openAgents: () => void;
+    /** Open the /subagent model panel. */
+    openSubagent: () => void;
+    /** Open the /todos subpage (full todo list in one bounded panel). */
+    openTodos: () => void;
+    openUsage: () => void;
+    /** Open the dedicated /delete picker, optionally pre-armed on one id. */
+    openDelete: (id?: string) => void;
+    openDiff: (argument: string) => void;
+    reviewChanges: (selection: ReviewSelection) => void;
+    /** Open the /review candidate picker (bare /review). */
+    openReviewPicker: () => void;
+    /** The row id awaiting y/n in this box, when a deletion is pending. */
+    deleteConfirm?: string;
+    /** Confirm the pending deletion (y in the box). */
+    confirmDelete: () => void;
+    /** Cancel the pending deletion (any other key in the box). */
+    cancelDelete: () => void;
+    createSession: (mode?: string) => void;
+    forkSession: (argument: string) => void;
+    cancelSessionSwitch: () => boolean;
+    notify: (text: string, tone?: NoticeTone) => void;
+    /** Apply the Ctrl+R passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
+    applyEditorKeys: () => Promise<string>;
+    hasNotice: boolean;
+    dismissNotice: () => void;
+    toggleReasoning: () => void;
+    openVerbose: () => void;
+    clearView: () => void;
+    refresh: () => void;
+    loadMentions: (query: string, signal?: AbortSignal) => Promise<readonly MentionCandidate[]>;
+    inspectImages: (paths: readonly string[]) => Promise<readonly ImagePathInspection[]>;
+    prepareImages: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly ImageBlock[]>;
+    inspectFiles: (paths: readonly string[]) => Promise<readonly FilePathInspection[]>;
+    prepareFiles: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly FileBlock[]>;
+    cycleMode: () => string;
+    exportTranscript: (argument: string) => Promise<void>;
+    renameTitle: (argument: string) => string;
+    copyLastResponse: () => Promise<string>;
+    /** Newest-first recall space (persistent + in-session, deduped). */
+    recallSpace: readonly string[];
+    /** Record one in-session submission (deduped, local only). */
+    recordLocal: (text: string) => void;
+    /** Persist one submission to the global history file. */
+    recordHistory: (text: string) => void;
+    /** Next-turn inbox rows, ordered exactly as the durable inbox. */
+    queued: readonly Extract<TranscriptEntry, {
+        kind: 'pending';
+    }>[];
+    updateQueued?: (messageId: string, action: QueueMutation) => void;
+    /** Accepted /history entry waiting to be placed into the composer. */
+    historyFill: {
+        text: string;
+        index: number;
+    } | undefined;
+    /** Marks the accepted entry consumed (called after the fill is applied). */
+    historyConsumed: () => void;
+    /** Whether timed animations run (shimmer, chase, blink, wave). */
+    animations: boolean;
+    /** Apply and report one /animation toggle (App persists through the runner). */
+    applyAnimations: (enabled: boolean) => void;
+    /** Reroll or pin the rainbow palette (switches to rainbow if needed). */
+    applyRainbow: (seed?: number) => void;
+    /** Monotonic id of the in-flight /rainbow composer burst; 0 means none. */
+    rainbowBurstId: number;
+    /** DeepSeek easter-egg wave tier of the applied route (null otherwise):
+     * official DeepSeek models drive their flash/pro tiers, non-DeepSeek
+     * models running an effort above high drive the "Into the Unknown"
+     * variant. Drives the persistent prompt glyph/accent and the sparkle
+     * tier. */
+    waveTier: DeepseekWaveTier | null;
+    /** The ignition style running, if any: Wave / Aurora / Pulse. */
+    waveStyle: DeepseekWaveStyle | null;
+    /** Maximum physical editor rows the composer may occupy (see composerMaxRows). */
+    maxRows: number;
+    /** Terminal rows below the composer the editor does not own: the status
+     * footer and Ink's parked cursor row. The IME anchor adds these to the
+     * caret's in-band offset to reach that parked position. */
+    anchorRowsBelow: number;
+    /** The managed terminal tab label; re-asserted on terminal focus-in so a
+     * background process sharing the console cannot keep it overwritten. */
+    tabTitle: string;
+    /** Reports the editor's current physical row count so the live budget stays exact. */
+    onEditorRows: (rows: number) => void;
+    /** Reports the open completion menu's physical row count (0 when closed)
+     * for the same reason: the dynamic budget must reserve it, not overflow. */
+    onMenuRows: (rows: number) => void;
+}): ReactElement;
+/** One cached settled row: the row Box plus its roomy-prompt spacers. */

package/lib/types/git-workflow.d.ts

@@ -119,3 +119,9 @@ export declare function parseReviewConclusion(text: string): ReviewConclusion |
  * priority plus the overall verdict, or a no-findings phrasing.
  */
 export declare function reviewSummaryLine(conclusion: ReviewConclusion): string;
+/**
+ * Resolve the working directory's git branch for the status line.
+ * @param cwd - the session's working directory.
+ * @returns the branch name, or '' outside a repository or on a detached HEAD.
+ */
+export declare function gitBranch(cwd: string): string;

package/lib/types/index.d.ts

@@ -10,13 +10,12 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import type { Agent, AgentStatus, Inbox } from '@deepseek-ai/dsh-agent';
-import { type ContentBlock } from '@deepseek-ai/dsh-llm';
-import { SessionId, type SessionEvent, type SessionHeader, type UserMessage } from '@deepseek-ai/dsh-session';
-import { type SessionPersistence } from '@deepseek-ai/dsh-session-persistence';
-import { type QueueMutation } from './app.ts';
-import type { TuiStartup } from './startup.ts';
-import type { SearchRow } from './kernel-panels.ts';
+export { planCycleDecision, type ModeCycleDecision } from './runner/mode-cycle.ts';
+export { runQuitSequence, type QuitCleanupStep } from './runner/quit.ts';
+export { exportSessionIdSuffix, resolveTarget } from './runner/session-target.ts';
+export { applyQueueMutation, cancelPreservingQueue, queueEditContent, StartupInputGate, submissionBelongsToSession, type QueuedSubmission, type QueueMutationOutcome, } from './runner/submissions.ts';
+export { subagentCatalogSeed } from './session/subagents.ts';
+export { searchHitToRow } from './runner/search-rows.ts';
 /** Stable Cordis plugin name. */
 export declare const name = "tui-runner";
 /** Core services required before the interactive session can start. */
@@ -34,190 +33,9 @@ export interface Config {
     };
 }
 export declare const Config: z<Config>;
-/** The session identity this invocation will run, plus whether it is resumed. */
-interface Target {
-    sessionId: string;
-    resume: boolean;
-    mode?: string;
-    cwd?: string;
-    seed?: readonly SessionEvent[];
-    parentSession?: SessionId;
-    /** Marks the session as a subagent conversation in the durable header. */
-    origin?: 'subagent';
-    seedLength?: number;
-}
-/**
- * Reduce a session id to a filename-safe /export default-name suffix. Session
- * ids are normally minted `session-<uuid>`, but `--session` accepts arbitrary
- * user text: path separators must never leak into the default export filename
- * (which would escape the session cwd).
- * @param id - the session id.
- * @returns at most the last 8 filename-safe characters.
- */
-export declare function exportSessionIdSuffix(id: string): string;
-/** One ordered step of the terminal quit cleanup. */
-export interface QuitCleanupStep {
-    /** Step label used in diagnostics and tests. */
-    readonly name: string;
-    /** The step's async work; a rejection is contained by the sequence. */
-    readonly run: () => Promise<void>;
-}
-/**
- * Run the ordered quit cleanup, then request exit. Every step rejection is
- * contained (reported through `onError`) so a failed flush or dispose never
- * skips the remaining cleanup; the exit request is always reached exactly
- * once.
- * @param steps - the cleanup steps in dependency order (settle the visible
- * session, await the final in-flight composition, await durable recall).
- * @param exit - the terminal exit request (code 0).
- * @param onError - optional failure sink; called once per failing step and
- * itself contained, so a throwing sink cannot abort the sequence.
- * @returns the names of the steps that started, in order (for tests).
- */
-export declare function runQuitSequence(steps: readonly QuitCleanupStep[], exit: (code: number) => void, onError?: (name: string, error: unknown) => void): Promise<readonly string[]>;
-/** One composer submission waiting behind the startup delivery. */
-export interface QueuedSubmission {
-    readonly text: string;
-    /** `steer` inserts into the running turn; `followup` waits for the next one. */
-    readonly mode: 'followup' | 'steer';
-    readonly images: readonly ContentBlock[];
-}
-/** What one requested queue mutation did; the runner maps it to one notice. */
-export type QueueMutationOutcome = 'removed' | 'edited' | 'steered' | 'unavailable' | 'empty' | 'steerUnavailable';
-/**
- * Replace one queued message's text while keeping its attachments. A queue
- * edit rewrites what the user typed, not what they attached: image and file
- * blocks ride through in delivery order (text first, then attachments, the
- * shape {@link deliverLine} submits). Dropping them here would silently strip
- * an attachment the user already confirmed, so this is the edit's single
- * definition and the panel's read-only marker only mirrors it.
- */
-export declare function queueEditContent(content: readonly ContentBlock[], text: string): ContentBlock[];
-/**
- * Apply one terminal queue mutation to the live inbox. The decision and the
- * inbox change are pure over the supplied handles so every branch is testable
- * without an agent; steering itself is injected because it wakes the driver
- * rather than mutating the inbox. The durable inbox splices remain the UI's
- * single source of truth — this helper never reports a state the inbox did not
- * actually reach.
- * @param inbox - the live agent inbox (pending lists plus its mutators).
- * @param status - the agent's lifecycle status; steering needs `running`.
- * @param messageId - identity of the queued message to mutate.
- * @param action - the requested mutation.
- * @param steer - submits the removed message as next-step steering.
- * @returns the outcome the caller reports.
- */
-export declare function applyQueueMutation(inbox: Pick<Inbox, 'nextTurn' | 'append' | 'remove' | 'replace'>, status: AgentStatus, messageId: string, action: QueueMutation, steer: (message: UserMessage) => void): QueueMutationOutcome;
-/**
- * Cancel the active turn while keeping the next-turn queue, then wake the
- * driver again so the preserved messages actually run. `cancel` clears
- * pending work by default and never wakes the driver on its own, so the queue
- * is captured first and re-submitted afterwards: a waking submission latches
- * the wake while the aborted activity converges to idle, which is what turns
- * "preserved" into "sent next" instead of "parked forever". Next-step
- * steering is deliberately dropped — it belonged to the cancelled turn.
- * @param agent - the live agent handle.
- * @returns how many queued messages were preserved across the abort.
- */
-export declare function cancelPreservingQueue(agent: Pick<Agent, 'inbox' | 'cancel' | 'followup'>): number;
-/**
- * Whether a tagged submission still belongs to the active session. Attachment
- * prepares resolve on the microtask timeline, while a queued session switch
- * remounts the app asynchronously — the composing instance's unmount cleanup
- * runs too late to abort, so the delivery itself carries the composing
- * session's full id and the runner drops it here when the world moved on.
- * An untagged (synchronous) or pending-session ('') submission always passes.
- */
-export declare function submissionBelongsToSession(origin: string | undefined, activeSessionId: string | undefined): boolean;
-/**
- * Root-log catalog facts a resumed session must replay into the subagent
- * feed: constructor seeds never fire on the live bus, so without this the
- * children of a resumed session vanish behind a restart. The empty-child
- * placeholder row (childId '') is a placeholder, not a child, and stays out.
- */
-export declare function subagentCatalogSeed(events: readonly SessionEvent[]): readonly SessionEvent<'subagent/catalog'>[];
-/**
- * Map one cross-session full-text hit onto the /search panel's row (pure).
- * Labels fall back to the short id form — the engine's hit carries the
- * strongest matching event, not the title observation.
- */
-export declare function searchHitToRow(hit: {
-    header: SessionHeader;
-    bestMatch: {
-        snippet: string;
-        time: number;
-    };
-}): SearchRow;
-/** One Shift+Tab station decision for the mode cycle. */
-export type ModeCycleDecision = {
-    readonly kind: 'permission';
-    readonly preset: string;
-} | {
-    readonly kind: 'plan-on';
-} | {
-    readonly kind: 'plan-off';
-    readonly preset: string;
-};
-/**
- * Decide the next Shift+Tab station. The cycle keeps the preset table's
- * own order (most restrictive first) and inserts ONE plan station between
- * the most restrictive preset and the wrap target: with the shipped three
- * presets the user sees workspace-write → danger-full-access → read-only
- * → plan → workspace-write. Plan IS the most restrictive preset plus the
- * plan prompt layer — entering it switches nothing (the cycle is already
- * parked on read-only), and leaving it lands on the next preset after the
- * most restrictive one. Without the /plan command the cycle is exactly the
- * preset table.
- *
- * `planIntent` covers the committed fold's commit lag: upstream queues a
- * plan switch during an open turn (and the command pipeline is async even
- * idle), so the durable plan/mode event lands AFTER the press that chose
- * it. While an intent from an earlier press is in flight it — not the
- * stale committed fold — decides the station, so repeated presses advance
- * the cycle instead of re-issuing the same plan transition (the stuck
- * plan-on/plan-off toggle). Undefined falls back to the committed fold.
- */
-export declare function planCycleDecision(input: {
-    readonly names: readonly string[];
-    readonly current: string;
-    readonly inPlan: boolean;
-    readonly planAvailable: boolean;
-    readonly planIntent?: boolean;
-}): ModeCycleDecision | undefined;
-/**
- * Order-preserving gate for composer input while the startup prompt/images
- * are still preparing. Anything submitted before the startup delivery settles
- * queues and flushes afterwards in submit order, so the initial request can
- * never be overtaken by typing that raced a slow image preparation. The flush
- * also runs when the startup delivery fails: user input is never stranded.
- */
-export declare class StartupInputGate {
-    private readonly deliver;
-    private readonly queued;
-    private pending;
-    constructor(deliver: (submission: QueuedSubmission) => void);
-    /** Submit one line: delivered now while idle, queued behind the startup delivery otherwise. */
-    submit(submission: QueuedSubmission): void;
-    /**
-     * Run the startup delivery — the callback receives the direct-delivery sink
-     * for the startup prompt itself — then flush everything that queued behind
-     * it, in order, even when the callback rejects.
-     */
-    run(startup: (deliver: (submission: QueuedSubmission) => void) => Promise<void>): Promise<void>;
-}
-/**
- * Resolve the invocation's target session against the persisted headers.
- * @param startup - the parsed startup flags.
- * @param persistence - the persistence service; required for resume/latest.
- * @param cwd - the working directory `--continue` filters by.
- * @returns the target identity.
- * @throws with a user-facing message when the flags name nothing resolvable.
- */
-export declare function resolveTarget(startup: TuiStartup, persistence: SessionPersistence | undefined, cwd: string): Promise<Target>;
 /**
  * Mount the interactive terminal driver.
  * @param ctx - plugin context carrying core services and the launcher-provided exit request.
  * @param config - validated startup config resolved from the tuiStartup provider.
  */
 export declare function apply(ctx: Context, config: Config): void;
-export {};

package/lib/types/locales/en.d.ts

@@ -86,8 +86,15 @@ export declare const en: {
     readonly 'schedule.titlePlural': "/schedule · {count} active reminders";
     readonly 'schedule.empty': "no active reminders — the model creates them with schedule_create";
     readonly 'document.loading': "loading transcript…";
+    readonly 'attach.bar': "observing · {label} · r reload · esc/ctrl+d back";
+    readonly 'attach.loading': "loading {label}'s conversation…";
+    readonly 'attach.status': "subagent {label} · {id} · {turns} turns";
+    readonly 'notice.attachUnavailable': "subagent attachment is unavailable in this profile";
     readonly 'document.compact': "transcript · esc close";
-    readonly 'document.footer': "lines {from}-{to}/{total} · ↑↓/pg/g/G · t/esc close";
+    readonly 'document.expanded': "expanded";
+    readonly 'document.refreshHint': "r refresh";
+    readonly 'document.footerExpanded': "lines {from}-{to}/{total} · ↑↓/pg/g/G{refresh} · esc/ctrl+d back";
+    readonly 'document.footer': "lines {from}-{to}/{total} · ↑↓/pg/g/G · enter/f expand · t/esc close";
     readonly 'review.picker.title': "/review · choose a target";
     readonly 'review.picker.uncommitted': "Review uncommitted changes (staged / unstaged / new files)";
     readonly 'review.picker.branch': "Compare against a base branch (lists local branches)";
@@ -417,7 +424,6 @@ export declare const en: {
     readonly 'panel.provider.notConfiguredDivider': "── not configured ──";
     readonly 'panel.provider.title': "/model — providers";
     readonly 'panel.provider.titleCount': "/model — providers · {index}/{total}";
-    readonly 'panel.provider.state': "{route} · {value}";
     readonly 'panel.provider.key': "key {value}";
     readonly 'panel.provider.authConfigured': "provider auth";
     readonly 'panel.provider.noKey': "key missing";
@@ -432,7 +438,7 @@ export declare const en: {
     readonly 'panel.provider.readOnlyLogin': "this login record is read-only";
     readonly 'panel.provider.notManaged': "this provider is not managed by Harness settings";
     readonly 'panel.providers.compact': "/model providers · enter configure · d remove key · esc back";
-    readonly 'panel.providers.footer': "↑↓ move · enter configure · l login · o logout · d remove key · x remove provider · r retry · esc back";
+    readonly 'panel.providers.footer': "↑↓ move · enter configure · d remove key · x remove provider · r retry · esc back";
     readonly 'panel.update.compact': "/update · {summary}";
     readonly 'panel.update.checking': "checking…";
     readonly 'panel.update.probeFailed': "probe failed";
@@ -460,8 +466,14 @@ export declare const en: {
     readonly 'panel.setup.copyInto': "copy verbatim into {id}";
     readonly 'panel.setup.copyTitle': "/model — copy efforts";
     readonly 'panel.setup.copyFooter': "↑↓ move · enter copy · esc back";
+    readonly 'panel.setup.mode.subscribe': "Subscription";
+    readonly 'panel.setup.mode.key': "Key";
+    readonly 'panel.setup.mode.login.plan': "signed in · plan";
+    readonly 'panel.setup.mode.login.none': "not signed in";
+    readonly 'panel.setup.mode.login.running': "signing in…";
+    readonly 'panel.setup.mode.overridden': "⚠ the settings key overrides the plan sign-in";
     readonly 'panel.setup.title': "/model — configure {provider}";
-    readonly 'panel.setup.footer': "↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab discover · enter save · esc back";
+    readonly 'panel.setup.footer': "↑↓ move · ←→ in/out · space remove · e efforts · c copy efforts · tab per channel (subscription = web sign-in, key = discover) · enter save · esc back";
     readonly 'panel.discovery.compact': "model discovery · terminal too small · esc back";
     readonly 'panel.discovery.loading': "discovering models…";
     readonly 'panel.discovery.empty': "the endpoint advertised no models; add ids by hand on the setup page";

package/lib/types/{authorization-panel.d.ts → panels/authorization-panel.d.ts}

@@ -2,9 +2,14 @@
 import { type ReactElement } from 'react';
 import { type AuthorizationInteraction, type AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
 import type { CredentialKey } from '@deepseek-ai/dsh-credentials';
-import type { ProviderAuthorizationRow } from './authorization.ts';
+import type { ProviderAuthorizationRow } from '../authorization.ts';
 export interface ProviderAuthorizationPanelProps {
     readonly row: ProviderAuthorizationRow;
+    /**
+     * Start this method immediately instead of showing the picker: a
+     * single-method provider signs in with no extra step.
+     */
+    readonly autoStartMethod?: string;
     begin(row: ProviderAuthorizationRow, method: string, interaction: AuthorizationInteraction, signal: AbortSignal): Promise<AuthorizationStatus>;
     cancel(key: CredentialKey): void;
     openUrl(url: string): boolean;

package/lib/types/panels/completion-panel.d.ts

@@ -0,0 +1,13 @@
+/** Bounded slash-command and mention completion menu. */
+import { type ReactElement } from 'react';
+import type { CompletionCandidate } from '../completion.ts';
+/** Total physical rows occupied by the completion menu at this terminal height. */
+export declare function completionMenuRowCount(terminalRows: number, rowCount: number): number;
+/** Completion view anchored directly above the composer band. */
+export declare function CompletionMenu({ active, mention, index, rows, error }: {
+    active: boolean;
+    mention: boolean;
+    index: number;
+    rows: readonly CompletionCandidate[];
+    error?: string;
+}): ReactElement | undefined;

package/lib/types/panels/interaction-bars.d.ts

@@ -0,0 +1,38 @@
+/** Approval and structured-question keyboard-owned terminal surfaces. */
+import { type ReactElement } from 'react';
+import type { ApprovalSnapshot } from '../approval.ts';
+import type { QuestionSnapshot, QuestionStore } from '../questions.ts';
+import type { NoticeTone } from '../ui/ui-contract.ts';
+/**
+ * The approval dialog (Codex ApprovalOverlay contract): a bold question
+ * header, the bounded command body with an explicit overflow marker, a
+ * numbered option list with a `›` cursor, single-key shortcuts, and digits
+ * for direct selection. Askers queue FIFO — the count rides the header.
+ * The upstream answerer vocabulary stays binary (`allowed-once` /
+ * `rejected`): "tell it what to do differently" rejects and hands the
+ * composer back with a hint notice, exactly Codex's decline-then-type flow.
+ */
+export declare function ApprovalBar({ snapshot, locked, notify, interrupt, summarize }: {
+    snapshot: ApprovalSnapshot;
+    locked: boolean;
+    notify: (text: string, tone?: NoticeTone) => void;
+    /** Cancel the running turn (Ctrl+C), matching the composer's busy branch. */
+    interrupt: () => boolean;
+    /** Render as the bounded one-line form even on tall terminals (another
+     * human-asked surface already owns the full panel budget). */
+    summarize?: boolean;
+}): ReactElement | undefined;
+/**
+ * The ask_user_question bar: walks one request question by question,
+ * retaining an independent draft for every question. Options use Space/1-9
+ * to toggle a multi-select, Enter to confirm, and arrows/Ctrl+P/N to move
+ * between questions. Plan reviews arrive through the same service with a
+ * `plan-review` intent — the approve option gets a ✓ mark, the answer
+ * encoding stays identical.
+ */
+export declare function QuestionBar({ store, snapshot, locked }: {
+    store: QuestionStore;
+    snapshot: QuestionSnapshot;
+    locked: boolean;
+}): ReactElement | undefined;
+/** The /model panel: a scrolling list over the advisory model directory. */