dsh-code 1.2.0 → 1.4.0

package/lib/startup.mjs

@@ -1,4 +1,4 @@
-import { r as THEME_NAMES } from "./theme-7u5Qo3dF.mjs";
+import { r as THEME_NAMES } from "./theme-B3orFUYz.mjs";
 import { Command } from "commander";
 import { parseCmdline } from "@deepseek-ai/dsh-cmdline";
 //#region src/startup.ts

package/lib/{theme-7u5Qo3dF.mjs → theme-B3orFUYz.mjs}

@@ -538,6 +538,10 @@ function hueOf([r, g, b]) {
 	if (max === g) return (60 * (b - r) / span + 120) % 360;
 	return (60 * (r - g) / span + 240) % 360;
 }
+/** Strict RGB equality for the wrap-collision repair. */
+function sameRgb(left, right) {
+	return left[0] === right[0] && left[1] === right[1] && left[2] === right[2];
+}
 /** A dark row tint for diff backgrounds: the hue at 22% strength over black. */
 function darkTint(hue) {
 	return [
@@ -603,6 +607,10 @@ function rollRainbow(seed) {
 	TONE_ORDER.forEach((tone, index) => {
 		toneColors[tone] = pool[(offset + index) % pool.length];
 	});
+	if (sameRgb(toneColors.live, toneColors.error)) {
+		const replacement = pool.find((hue) => !sameRgb(hue, toneColors.live) && !sameRgb(hue, toneColors.warn));
+		if (replacement !== void 0) toneColors.error = replacement;
+	}
 	return {
 		seed,
 		palette,

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[];
@@ -234,32 +230,24 @@ export interface AppProps {
     /** Apply the Ctrl+R terminal passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
     applyEditorKeys: () => Promise<string>;
 }
+/**
+ * The streaming buffer rendered with a hard size cap: the live region must
+ * ALWAYS fit the terminal, or Ink's erase/rewrite of a dynamic tree taller
+ * than the screen freezes (cursor-up past the top, garbage, no scroll). The
+ * cap counts explicit newlines and terminal wrapping, slicing from the END so
+ * the freshest tokens stay visible while a long reply streams; the complete
+ * text lands in the flushed scrollback once the turn assembles it.
+ *
+ * Body wrap width for a streaming tail. `rowColumns` is the same width
+ * passed to `transcriptEntryLines` (terminal minus the last-column safety);
+ * the hanging prefix then shrinks the body so streamed text and settled
+ * markdown wrap on the same column.
+ */
+export declare function streamTailBodyColumns(rowColumns: number, prefix: string, continuationPrefix?: string): number;
 /** Rows in the exact next-turn inbox order, never transcript append order. */
 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';
-}
-/**
- * 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;
@@ -345,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/attachments.d.ts

@@ -26,17 +26,26 @@ export declare const MAX_FILES_PER_MESSAGE = 8;
 export declare function detectImageMediaType(data: Uint8Array): ImageMediaType | undefined;
 /** Whether a path-like token is worth probing as an image attachment. */
 export declare function looksLikeImagePath(path: string): boolean;
+/** Strip one layer of ASCII or Unicode quotes and shell-escaped spaces. */
+export declare function unwrapDroppedPath(token: string): string;
+/** Absolute/relative drop with a dotted leaf — including unquoted spaces. */
+export declare function looksLikeFilesystemDrop(path: string): boolean;
 /**
- * Parse a paste/drop into its image and file paths: image-suffixed tokens
- * stay images, other path-shaped tokens ride as file attachments (0.1.5
- * file blocks), and anything that is neither leaves both empty — the caller
- * then treats the paste as plain text.
+ * A composer draft that is a filesystem path, not a slash command.
+ * `/usage` stays a command; `/Users/foo.png` and `C:\temp\a.png` are drops.
+ */
+export declare function looksLikePathDraft(value: string): boolean;
+/**
+ * Parse a paste or file-drop into image and file paths: image-suffixed
+ * tokens stay images, other path-shaped tokens ride as file attachments
+ * (0.1.5 file blocks), and anything that is neither leaves both empty —
+ * the caller then treats the paste as plain text.
  *
  * File tokens are held to an absolute-path-with-shape bar (drive/backslash
- * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * or a dotted leaf after a separator): a dropped terminal path always
  * carries one of those, while prose, slash commands, and option flags never
- * do. A POSIX absolute path without any dot-suffixed leaf falls through as
- * text — the @ mention route still attaches such files deliberately.
+ * do. A POSIX absolute path without a dotted leaf falls through as text —
+ * the @ mention route still attaches such files deliberately.
  */
 export declare function parsePastedAttachmentPaths(input: string): {
     readonly images: readonly string[];

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 {};