dsh-code 1.0.6 → 1.2.0

package/lib/types/app.d.ts

@@ -18,6 +18,8 @@ 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 TranscriptEntry } from './render/projection.ts';
 import type { ApprovalStore } from './approval.ts';
@@ -28,16 +30,26 @@ 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 JobRow } from './kernel-panels.ts';
+import type { UsageView } from './render/usage.ts';
+import { type JobRow, type SearchRow } from './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 } from './git-workflow.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';
+};
 /** Props the runner hands the app; callbacks stay owned by the runner. */
 export interface AppProps {
     /** Event-fed transcript store for the live session. */
@@ -76,124 +88,156 @@ export interface AppProps {
      * an attachment prepare resolves after the app remounted onto another
      * session, and the runner drops the stale delivery then.
      */
-    dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
-    /** Submit steering, with the same stale-delivery guard as {@link dispatch}. */
-    steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
+    dispatch: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void;
+    /**
+     * Submit one line as steering: it joins the turn already running at its next
+     * step boundary instead of waiting for the next turn. Same stale-delivery
+     * guard as {@link dispatch}.
+     */
+    steer: (text: string, attachments?: readonly ContentBlock[], origin?: string) => void;
     /**
      * The FULL current session identity ('' while the first session is pending)
      * — the stale-delivery origin above. Distinct from the short display id.
      */
     sessionKey: string;
     /** Interrupt the running turn (Esc); true when a turn was cancelled. */
-    interrupt(): boolean;
+    interrupt: () => boolean;
     /** Quit: unmount, flush, and request process exit. */
-    quit(): void;
+    quit: () => void;
     /** Load the selectable model directory (called when /model opens). */
-    loadModels(): Promise<ModelDirectory>;
+    loadModels: () => Promise<ModelDirectory>;
     /** Load @mention candidates for the typed query (files + sessions). */
-    loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
+    loadMentions: (query: string, signal?: AbortSignal) => Promise<readonly MentionCandidate[]>;
     /** Validate draft image paths without committing attachment objects. */
-    inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>;
+    inspectImages: (paths: readonly string[]) => Promise<readonly ImagePathInspection[]>;
     /** Validate, normalize and persist images immediately before submission. */
-    prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>;
+    prepareImages: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly ImageBlock[]>;
     /** Validate draft non-image file paths without committing attachment objects. */
-    inspectFiles(paths: readonly string[]): Promise<readonly FilePathInspection[]>;
+    inspectFiles: (paths: readonly string[]) => Promise<readonly FilePathInspection[]>;
     /** Persist non-image files immediately before submission as durable file blocks. */
-    prepareFiles(paths: readonly string[], signal?: AbortSignal): Promise<readonly FileBlock[]>;
+    prepareFiles: (paths: readonly string[], signal?: AbortSignal) => Promise<readonly FileBlock[]>;
     /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
-    selectModel(row: ModelRow, effortId?: string): string;
+    selectModel: (row: ModelRow, effortId?: string) => string;
     /** The /subagent override label, '' when delegated agents follow the current model. */
     subagentModel: string;
     /** Apply one /subagent model pick; returns the override label. */
-    setSubagentModel(row: ModelRow, effortId?: string): string;
+    setSubagentModel: (row: ModelRow, effortId?: string) => string;
     /** Drop the /subagent override (delegated agents follow the current model). */
-    clearSubagentModel(): void;
+    clearSubagentModel: () => void;
     /** Delete one session subtree; resolves with the outcome line. */
-    deleteSession(id: string): Promise<string>;
+    deleteSession: (id: string) => Promise<string>;
     /** Load provider/settings/credential facts for the optional /model provider stage. */
-    loadModelProviders?(): Promise<ProviderSettingsDirectory>;
+    loadModelProviders?: () => Promise<ProviderSettingsDirectory>;
     /** Subscribe to Harness credential/settings/adapter invalidations while /model is open. */
-    subscribeModelProviders?(listener: () => void): () => void;
+    subscribeModelProviders?: (listener: () => void) => () => void;
     /** Store or rotate one provider credential through the Harness credential service. */
-    saveModelProviderCredential?(target: ProviderTargetView, key: string): Promise<void>;
+    saveModelProviderCredential?: (target: ProviderTargetView, key: string) => Promise<void>;
     /** Remove one writable provider credential without removing its settings profile. */
-    unsetModelProviderCredential?(target: ProviderTargetView): Promise<void>;
+    unsetModelProviderCredential?: (target: ProviderTargetView) => Promise<void>;
     /** Remove one user-owned provider profile and its page-managed credential. */
-    removeModelProvider?(target: ProviderTargetView): Promise<void>;
+    removeModelProvider?: (target: ProviderTargetView) => Promise<void>;
     /** Save endpoint and explicit model capacities through the provider profile. */
-    saveModelProviderConfiguration?(target: ProviderTargetView, configuration: ProviderConfiguration): Promise<void>;
+    saveModelProviderConfiguration?: (target: ProviderTargetView, configuration: ProviderConfiguration) => Promise<void>;
     /**
      * Interrogate the provider's real endpoint (typed key wins over the stored
      * credential) for the models it actually serves — the discovery stage of
      * the provider setup page.
      */
-    discoverModelProvider?(target: ProviderTargetView, request: {
+    discoverModelProvider?: (target: ProviderTargetView, request: {
         readonly apiKey?: string;
         readonly baseURL?: string;
-    }, signal?: AbortSignal): Promise<readonly DiscoveredModelView[]>;
+    }, signal?: AbortSignal) => Promise<readonly DiscoveredModelView[]>;
     /** Provider authorization flows and value-free stored-record facts. */
-    loadProviderAuthorizations?(): Promise<ProviderAuthorizationDirectory>;
-    subscribeProviderAuthorizations?(listener: () => void): () => void;
-    beginProviderAuthorization?(row: ProviderAuthorizationRow, method: string, interaction: AuthorizationInteraction, signal: AbortSignal): Promise<AuthorizationStatus>;
-    cancelProviderAuthorization?(row: ProviderAuthorizationRow): void;
-    logoutProviderAuthorization?(row: ProviderAuthorizationRow): Promise<void>;
-    openAuthorizationUrl?(url: string): boolean;
-    copyTextValue?(text: string): Promise<void>;
-    /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
-    cyclePermission(): string;
+    loadProviderAuthorizations?: () => Promise<ProviderAuthorizationDirectory>;
+    subscribeProviderAuthorizations?: (listener: () => void) => () => void;
+    beginProviderAuthorization?: (row: ProviderAuthorizationRow, method: string, interaction: AuthorizationInteraction, signal: AbortSignal) => Promise<AuthorizationStatus>;
+    cancelProviderAuthorization?: (row: ProviderAuthorizationRow) => void;
+    logoutProviderAuthorization?: (row: ProviderAuthorizationRow) => Promise<void>;
+    openAuthorizationUrl?: (url: string) => boolean;
+    copyTextValue?: (text: string) => Promise<void>;
+    /** Cycle to the next mode station (Shift+Tab): a permission preset or a plan switch; returns the notice label. */
+    cycleMode: () => string;
+    /** Pre-session plan choice: shows the plan badge before the first session exists. */
+    pendingPlan?: boolean;
     /** Select or inspect a permission preset without requiring a pre-existing session. */
-    setPermission(id: string): string;
+    setPermission: (id: string) => string;
     /** Export the transcript to a markdown file (/export [path]); reports via notices. */
-    exportTranscript(argument: string): Promise<void>;
+    exportTranscript: (argument: string) => Promise<void>;
     /** Rename the session (/title <text>); returns the outcome line for the notice. */
-    renameTitle(argument: string): string;
+    renameTitle: (argument: string) => string;
     /** Copy the latest complete assistant response; resolves to notice text. */
-    copyLastResponse(): Promise<string>;
+    copyLastResponse: () => Promise<string>;
     /** Load a complete read-only Git diff for the file-oriented viewport. */
-    loadGitDiff(argument: string): Promise<GitDiffView>;
+    loadGitDiff: (argument: string) => Promise<GitDiffView>;
+    /** Local branches for the /review picker (absent: the picker hides the branch phase's list). */
+    listReviewBranches?: (signal?: AbortSignal) => Promise<readonly ReviewBranch[]>;
+    /** Recent commits on the current branch for the /review picker. */
+    listReviewCommits?: (signal?: AbortSignal) => Promise<readonly ReviewCommit[]>;
     /** Start a model review after applying the read-only permission preset. */
-    reviewChanges(argument: string): void;
+    reviewChanges: (selection: ReviewSelection) => void;
     /** Preset/session/plugin kernel operations. */
-    loadPresets(): Promise<readonly PresetRow[]>;
-    switchMode(id: string): Promise<string>;
+    loadPresets: () => Promise<readonly PresetRow[]>;
+    switchMode: (id: string) => Promise<string>;
     /** Load the switchable permission presets for the /permission panel. */
-    loadPermissions(): Promise<readonly PermissionRow[]>;
-    createSession(mode?: string): void;
+    loadPermissions: () => Promise<readonly PermissionRow[]>;
+    createSession: (mode?: string) => void;
     /** Fork the active session at a completed-turn boundary. */
-    forkSession(argument: string): void;
-    loadSessions(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
-    loadSessionTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    forkSession: (argument: string) => void;
+    loadSessions: (options: SessionDirectoryOptions, signal?: AbortSignal) => Promise<readonly SessionRow[]>;
+    loadSessionTranscript: (id: string, signal?: AbortSignal) => Promise<string>;
+    /** Read the current session's usage blocks (projections plus per-turn fold). */
+    loadUsage: () => Promise<UsageView>;
+    /**
+     * Full-text search over every persisted session (the in-process
+     * session-query engine). Absent when the deployment disabled the row;
+     * /search degrades to a notice instead of opening the panel.
+     */
+    searchSessions?: (query: string, signal?: AbortSignal) => Promise<readonly SearchRow[]>;
     /** Load this session's subagent conversations (children by lineage). */
-    loadSubagents(): Promise<readonly SessionRow[]>;
-    switchSession(row: SessionRow): void;
-    cancelSessionSwitch(): boolean;
-    loadPlugins(): readonly PluginRow[];
+    loadSubagents: () => Promise<readonly SessionRow[]>;
+    switchSession: (row: SessionRow) => void;
+    cancelSessionSwitch: () => boolean;
+    loadPlugins: () => readonly PluginRow[];
     /** Caller-visible background jobs (the host jobs registry, read-only). */
-    loadJobs(): readonly JobRow[];
+    loadJobs: () => readonly JobRow[];
+    /** Probe the launcher's aligned update plan (read-only; never installs). */
+    probeUpdate: () => Promise<LauncherUpdateStatus>;
+    /** Run the launcher's aligned update; streams sanitized lines; resolves with the exit code. */
+    applyUpdate: (onLine: (line: string) => void, plan?: {
+        readonly dshSpec: string;
+        readonly codeSpec: string;
+        readonly pluginSpecs: readonly string[];
+    }) => Promise<number>;
     /** Registers the app's notice channel with the runner (called once on mount). */
-    onBridgeReady(bridge: {
-        notify(text: string, tone?: NoticeTone): void;
-    }): void;
+    onBridgeReady: (bridge: {
+        notify: (text: string, tone?: NoticeTone) => void;
+    }) => void;
     /** Ordered enabled status items (/statusline config); the runner owns persistence. */
     statusline: readonly string[];
     /** Persist a new statusline item set; the runner surfaces IO failures as notices. */
-    saveStatusline(items: readonly string[]): void;
+    saveStatusline: (items: readonly string[]) => void;
+    /** Apply and persist one /language selection; the runner owns the language.json file. */
+    saveLanguage: (name: LanguageName) => void;
     /** Apply and persist one /theme selection; the runner owns the theme.json file. */
-    saveTheme?(name: ThemeName): void;
+    saveTheme?: (name: ThemeName) => void;
     /** Whether timed animations run at startup (animations.json; on by default
      * — like parseAnimationsPref, only an explicit false disables them). */
     animations?: boolean;
     /** Apply and persist one /animation toggle; the runner owns the file. */
-    saveAnimations?(enabled: boolean): void;
+    saveAnimations?: (enabled: boolean) => void;
     /** Persistent cross-session input history (oldest first); the runner owns the file. */
     history: readonly string[];
     /** Persist one submitted prompt to the global history file. */
-    recordHistory(text: string): void;
-    /** Cancel one queued inbox message by identity (Delete on the empty composer). */
-    cancelQueued(messageId: string): void;
+    recordHistory: (text: string) => void;
+    /** Mutate one next-turn inbox message; durable inbox splices reconcile the result. */
+    updateQueued?: (messageId: string, action: QueueMutation) => void;
     /** Apply the Ctrl+R terminal passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
-    applyEditorKeys(): Promise<string>;
+    applyEditorKeys: () => Promise<string>;
 }
+/** 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). */

package/lib/types/authorization-panel.d.ts

@@ -16,7 +16,7 @@ export interface ProviderAuthorizationPanelProps {
 export declare function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProps): ReactElement;
 export declare function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
     row: ProviderAuthorizationRow;
-    confirm(row: ProviderAuthorizationRow): Promise<void>;
-    done(): void;
-    back(): void;
+    confirm: (row: ProviderAuthorizationRow) => Promise<void>;
+    done: () => void;
+    back: () => void;
 }): ReactElement;

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

@@ -28,5 +28,94 @@ export declare function parseGitDiffSpec(argument: string): GitDiffSpec;
  * git subprocess instead of letting a stale repository's diff land later.
  */
 export declare function loadGitDiff(cwd: string, argument: string, signal?: AbortSignal): Promise<GitDiffView>;
-/** Review prompt capped before it reaches a provider context window. */
-export declare function buildReviewPrompt(diff: string, label: string, maxChars?: number): string;
+/** One /review run's selection: what to review plus an optional user note. */
+export type ReviewSelection = {
+    readonly kind: 'uncommitted';
+} | {
+    readonly kind: 'base-branch';
+    readonly branch: string;
+    readonly mergeBase?: string;
+} | {
+    readonly kind: 'commit';
+    readonly sha: string;
+} | {
+    readonly kind: 'custom';
+    readonly instructions: string;
+};
+/**
+ * The /review argument is always a free-form note applied to the uncommitted
+ * working tree (`/review 使用中文` reviews the uncommitted diff in Chinese);
+ * branch and commit targets come from the candidate picker, never from
+ * argument guessing.
+ */
+export declare function parseReviewArgument(argument: string): ReviewSelection;
+/** The merge base of HEAD and one branch, or undefined when git cannot compute one. */
+export declare function mergeBaseWith(cwd: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
+/** One commit's own patch (parent..commit), falling back to `git show` for root commits. */
+export declare function loadCommitDiff(cwd: string, sha: string, signal?: AbortSignal): Promise<GitDiffView>;
+/**
+ * Build the in-session review prompt: the diff is pasted whole (truncated at
+ * the character cap with an explicit marker the model can see), the rubric's
+ * essentials ride along — P0-P3 priorities, file/line anchors, only defects
+ * this change introduced — and an optional user note (language, focus)
+ * prefixes everything as the user's explicit instruction.
+ */
+export declare function buildReviewPrompt(diff: string, label: string, note?: string, maxChars?: number): string;
+/** One branch candidate for the review picker. */
+export interface ReviewBranch {
+    readonly name: string;
+}
+/** One commit candidate for the review picker. */
+export interface ReviewCommit {
+    readonly sha: string;
+    readonly title: string;
+    /** Committer timestamp in Unix epoch milliseconds. */
+    readonly at: number;
+}
+/**
+ * Local branch names for the review picker, newest activity first and with
+ * the current branch excluded (reviewing against it is always empty).
+ */
+export declare function listReviewBranches(cwd: string, signal?: AbortSignal): Promise<readonly ReviewBranch[]>;
+/** Recent commits on the current branch for the review picker. */
+export declare function listReviewCommits(cwd: string, signal?: AbortSignal, limit?: number): Promise<readonly ReviewCommit[]>;
+/** One finished review, ready for the terminal's result panel. */
+export interface ReviewResultView {
+    /** Panel header naming what was reviewed. */
+    readonly title: string;
+    /** The reviewer's reply markdown (the findings list). */
+    readonly body: string;
+    /** Compact summary: finding counts per priority plus the verdict. */
+    readonly summary: string;
+    /** The review session id, so follow-ups can @-reference its context. */
+    readonly sessionId: string;
+}
+/** One parsed review finding from the reviewer's closing JSON block. */
+export interface ReviewFinding {
+    /** Priority 0-3 for P0-P3; undefined when the reviewer omitted it. */
+    readonly priority?: number;
+    /** Finding title, already free of the [P#] prefix when present. */
+    readonly title: string;
+    /** File path the finding anchors to, when stated. */
+    readonly path?: string;
+    /** Line range as written, when stated. */
+    readonly range?: string;
+}
+/** The parsed conclusion of one review reply. */
+export interface ReviewConclusion {
+    readonly findings: readonly ReviewFinding[];
+    readonly overall?: 'correct' | 'incorrect';
+    readonly explanation?: string;
+}
+/**
+ * Parse the reviewer's reply into a conclusion: whole-text JSON first, then
+ * the first balanced JSON object anywhere in the text, then undefined (the
+ * reply renders as plain markdown with no summary line). Malformed fields
+ * are dropped, never thrown.
+ */
+export declare function parseReviewConclusion(text: string): ReviewConclusion | undefined;
+/**
+ * One compact summary line for a finished review: finding counts per
+ * priority plus the overall verdict, or a no-findings phrasing.
+ */
+export declare function reviewSummaryLine(conclusion: ReviewConclusion): string;

package/lib/types/i18n.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Interface language for the TUI: a module-level current language with a
+ * message accessor, mirroring the theme module's setTheme/getPalette shape
+ * so a language switch re-renders every translated surface on the next
+ * render without touching call sites. English is the default; the persisted
+ * choice lives in language.json next to theme.json (see the runner's
+ * persistence block).
+ *
+ * @module @deepseek-ai/dsh-tui/i18n
+ */
+import { type MessageKey } from './locales/en.ts';
+export type { MessageKey } from './locales/en.ts';
+/** Selectable interface languages: English (default) and Chinese. */
+export type LanguageName = 'en' | 'zh';
+/** Valid language names for argument parsing. */
+export declare const LANGUAGE_NAMES: readonly LanguageName[];
+/** One language's picker row. */
+export interface LanguageDescriptor {
+    readonly id: LanguageName;
+    readonly label: string;
+}
+/** The /language picker rows in canonical order. */
+export declare const LANGUAGES: readonly LanguageDescriptor[];
+/**
+ * Parse a persisted or typed language name: only 'en' and 'zh' survive;
+ * anything else falls back to English.
+ */
+export declare function parseLanguageName(value: unknown): LanguageName;
+/** The language name in force. */
+export declare function getLanguage(): LanguageName;
+/** Switch the active language; the next render paints with the new catalog. */
+export declare function setLanguage(name: LanguageName): void;
+/**
+ * One message from the active catalog, with `{n}`-style placeholders filled
+ * from the params record. Unknown placeholders stay literal; a missing key
+ * falls back to the English entry so a catalog gap degrades visibly but
+ * never crashes.
+ */
+export declare function t(key: MessageKey, params?: Readonly<Record<string, string | number>>): string;

package/lib/types/index.d.ts

@@ -10,10 +10,13 @@
  */
 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 } from '@deepseek-ai/dsh-session';
+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';
 /** Stable Cordis plugin name. */
 export declare const name = "tui-runner";
 /** Core services required before the interactive session can start. */
@@ -39,6 +42,8 @@ interface Target {
     cwd?: string;
     seed?: readonly SessionEvent[];
     parentSession?: SessionId;
+    /** Marks the session as a subagent conversation in the durable header. */
+    origin?: 'subagent';
     seedLength?: number;
 }
 /**
@@ -73,9 +78,48 @@ export declare function runQuitSequence(steps: readonly QuitCleanupStep[], exit:
 /** 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
@@ -85,6 +129,61 @@ export interface QueuedSubmission {
  * 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

package/lib/types/input-split.d.ts

@@ -50,5 +50,5 @@ export interface TuiStdin extends PassThrough {
  */
 export declare function createSplitStdin(source: NodeJS.ReadStream): {
     stdin: TuiStdin;
-    dispose(): void;
+    dispose: () => void;
 };