@gajae-code/coding-agent 0.11.1 → 0.11.3

package/dist/types/modes/components/command-palette.d.ts

@@ -0,0 +1,27 @@
+import { Container } from "@gajae-code/tui";
+export interface CommandPaletteAction {
+    id: string;
+    label: string;
+    handler: () => void | Promise<void>;
+}
+export interface CommandPaletteEntry {
+    id: string;
+    label: string;
+    description?: string;
+    category?: string;
+    keybinding?: string;
+    bindingHint?: string;
+    searchText?: string;
+    handler?: () => void | Promise<void>;
+    disabled?: boolean;
+}
+export declare class CommandPaletteComponent extends Container {
+    #private;
+    constructor(entries: CommandPaletteEntry[], onSelect: (entry: CommandPaletteEntry) => void, onCancel: () => void);
+    render(width: number): string[];
+    handleInput(data: string): void;
+    getEntries(): readonly CommandPaletteEntry[];
+}
+/** Backward-compatible name retained for extensions and existing call sites. */
+export declare class CommandPalette extends CommandPaletteComponent {
+}

package/dist/types/modes/components/custom-provider-wizard.d.ts

@@ -7,4 +7,5 @@ export declare class CustomProviderWizardComponent extends Container {
     constructor(onSubmit: (input: CustomProviderWizardSubmit) => void, onCancel: () => void, onRender?: () => void);
     setSubmitError(error: string): void;
     handleInput(keyData: string): void;
+    complete(): void;
 }

package/dist/types/modes/components/index.d.ts

@@ -2,6 +2,7 @@ export * from "./assistant-message";
 export * from "./bash-execution";
 export * from "./bordered-loader";
 export * from "./branch-summary-message";
+export * from "./chrome";
 export * from "./compaction-summary-message";
 export * from "./countdown-timer";
 export * from "./custom-editor";
@@ -22,11 +23,11 @@ export * from "./read-tool-group";
 export * from "./session-selector";
 export * from "./settings-selector";
 export * from "./show-images-selector";
-export * from "./status-line";
 export * from "./theme-selector";
 export * from "./thinking-selector";
 export * from "./todo-reminder";
 export * from "./tool-execution";
+export * from "./tool-status-header";
 export * from "./tree-selector";
 export * from "./ttsr-notification";
 export * from "./user-message";

package/dist/types/modes/components/pet-selector.d.ts

@@ -1,4 +1,4 @@
-import { Container, SelectList } from "@gajae-code/tui";
+import { Container, type SelectList } from "@gajae-code/tui";
 import type { PetMode } from "./gajae-pet-widget";
 /**
  * Theme-style picker for the gajae pet skin (Off / RedGajae / BlueGajae). Preview

package/dist/types/modes/components/plan-preview-overlay.d.ts

@@ -0,0 +1,43 @@
+import { Container, type KeyId, type MouseEvent } from "@gajae-code/tui";
+export declare const PLAN_REVIEW_ACTIONS: readonly ["Approve and execute", "Approve and compact context", "Approve and keep context", "Refine plan"];
+export type PlanReviewAction = (typeof PLAN_REVIEW_ACTIONS)[number];
+export type PlanPreviewFocus = "preview" | "sourceSelect" | "commentInput" | "actionBar";
+export interface PlanPreviewOptions {
+    externalEditorKey?: string;
+    externalEditorKeys?: readonly KeyId[];
+    onExternalEditor?: () => Promise<string | null>;
+}
+export interface PlanComment {
+    id: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+    snapshotHash: string;
+    createdAt: number;
+}
+export interface PlanPreviewResult {
+    action?: PlanReviewAction;
+    comments: PlanComment[];
+    notes: string;
+    snapshotHash: string;
+}
+export declare function planSnapshotHash(content: string): string;
+export declare function serializePlanReviewComments(content: string, hash: string, comments: readonly PlanComment[], notes?: string): string;
+/** Modal pre-decision review. Its result is consumed by InteractiveMode, which owns audit and dispatch semantics. */
+export declare class PlanPreviewOverlay extends Container {
+    #private;
+    private readonly done;
+    private readonly requestRender;
+    private readonly options;
+    content: string | null;
+    snapshotHash: string;
+    lines: string[];
+    constructor(content: string | null, done: (result: PlanPreviewResult) => void, requestRender: () => void, options?: PlanPreviewOptions);
+    get focusState(): PlanPreviewFocus;
+    get comments(): readonly PlanComment[];
+    get pageOffset(): number;
+    get sourceLine(): number;
+    render(width: number): string[];
+    handleMouse(event: MouseEvent): void;
+    handleInput(key: string): void;
+}

package/dist/types/modes/components/queue-mode-selector.d.ts

@@ -1,4 +1,4 @@
-import { Container, SelectList } from "@gajae-code/tui";
+import { Container, type SelectList } from "@gajae-code/tui";
 /**
  * Component that renders a queue mode selector with borders
  */

package/dist/types/modes/components/queue-pane.d.ts

@@ -0,0 +1,12 @@
+import { Container } from "@gajae-code/tui";
+import type { QueuedMessageEditEntry } from "../../session/agent-session";
+export declare class QueuePaneComponent extends Container {
+    #private;
+    constructor(entries: QueuedMessageEditEntry[], options: {
+        selectedIndex?: number;
+        onDelete: (entry: QueuedMessageEditEntry, index: number) => void;
+        onMove: (entry: QueuedMessageEditEntry, index: number, direction: "up" | "down") => void;
+        onClose: () => void;
+    });
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/read-tool-group.d.ts

@@ -24,7 +24,13 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
         isError?: boolean;
     }, isPartial?: boolean, toolCallId?: string): void;
     setArgsComplete(_toolCallId?: string): void;
+    /** Applies automatic expansion unless this renderer instance has an explicit fold choice. */
     setExpanded(expanded: boolean): void;
+    /**
+     * Applies and pins an explicit fold choice for this renderer instance only.
+     * Transcript rebuilds recreate components from global state and drop this pin.
+     */
+    setManuallyExpanded(expanded: boolean): void;
     getComponent(): Component;
 }
 export {};

package/dist/types/modes/components/session-observer-overlay.d.ts

@@ -1,11 +1,10 @@
-import { Container } from "@gajae-code/tui";
 import type { KeyId } from "../../config/keybindings";
 import type { SessionObserverRegistry } from "../session-observer-registry";
-export declare class SessionObserverOverlayComponent extends Container {
+import { TranscriptViewerOverlay } from "./transcript-viewer-overlay";
+/** Session-observer adapter. The shared viewer owns navigation and fold state. */
+export declare class SessionObserverOverlayComponent extends TranscriptViewerOverlay {
     #private;
     constructor(registry: SessionObserverRegistry, onDone: () => void, observeKeys: KeyId[]);
-    render(width: number): string[];
-    /** Rebuild content from live registry data */
     refreshFromRegistry(): void;
     handleInput(keyData: string): void;
 }

package/dist/types/modes/components/sessions-dashboard.d.ts

@@ -0,0 +1,32 @@
+import { Container } from "@gajae-code/tui";
+import type { SessionInfo } from "../../session/session-manager";
+export type SessionLiveness = "active" | "stale" | "unknown";
+export interface DashboardSession {
+    id: string;
+    cwd: string;
+    title: string;
+    modified: Date;
+    messageCount: number;
+    messageCountIsEstimate?: boolean;
+    liveness: SessionLiveness;
+}
+/**
+ * Reads the opt-in presence sidecar beside a session transcript. A missing or
+ * malformed sidecar deliberately means unknown: transcript modification time is
+ * not a process-liveness signal.
+ */
+export declare function sessionLivenessFromPresence(sessionPath: string, readFile?: (filePath: string) => string, now?: number): SessionLiveness;
+export declare function dashboardSessions(sessions: readonly SessionInfo[], options?: {
+    readFile?: (filePath: string) => string;
+    now?: number;
+}): DashboardSession[];
+/** Read-only top-level inventory. This component never opens, resumes, or mutates a session. */
+export declare class SessionsDashboardComponent extends Container {
+    #private;
+    private readonly sessions;
+    private readonly onClose;
+    private readonly requestRender?;
+    constructor(sessions: readonly DashboardSession[], onClose: () => void, requestRender?: (() => void) | undefined);
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}

package/dist/types/modes/components/settings-selector.d.ts

@@ -4,7 +4,7 @@ import { type Component, Container } from "@gajae-code/tui";
 import { type SettingPath } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { type NotificationsEditorOperations } from "./notifications-settings-editor";
-import type { StatusLineSegmentOptions } from "./status-line";
+import type { StatusLineSegmentOptions } from "./tool-status-header";
 /**
  * Dynamic context for settings that need runtime data.
  * Some settings (like thinking level) are managed by the session, not Settings.

package/dist/types/modes/components/show-images-selector.d.ts

@@ -1,4 +1,4 @@
-import { Container, SelectList } from "@gajae-code/tui";
+import { Container, type SelectList } from "@gajae-code/tui";
 /**
  * Component that renders a show images selector with borders
  */

package/dist/types/modes/components/status-line/types.d.ts

@@ -1,7 +1,7 @@
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../../config/settings-schema";
 import type { AgentSession } from "../../../session/agent-session";
 import type { JobsSnapshot } from "../../jobs-observer";
-import type { StatusLineSegmentOptions, StatusLineSettings } from "../status-line";
+import type { StatusLineSegmentOptions, StatusLineSettings } from "../tool-status-header";
 export type { StatusLinePreset, StatusLineSegmentId, StatusLineSegmentOptions, StatusLineSeparatorStyle, StatusLineSettings, };
 export type RGB = readonly [number, number, number];
 export interface SegmentContext {

package/dist/types/modes/components/status-line.d.ts

@@ -1,94 +1 @@
-import { type Component } from "@gajae-code/tui";
-import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
-import type { AgentSession } from "../../session/agent-session";
-import { type SkillActiveEntry } from "../../skill-state/active-state";
-import { type JobsSnapshot } from "../jobs-observer";
-export interface StatusLineSegmentOptions {
-    model?: {
-        showThinkingLevel?: boolean;
-        showContextPercent?: boolean;
-    };
-    path?: {
-        abbreviate?: boolean;
-        maxLength?: number;
-        stripWorkPrefix?: boolean;
-    };
-    git?: {
-        showBranch?: boolean;
-        showStaged?: boolean;
-        showUnstaged?: boolean;
-        showUntracked?: boolean;
-    };
-    time?: {
-        format?: "12h" | "24h";
-        showSeconds?: boolean;
-    };
-    usage?: {
-        mode?: "used" | "remaining";
-    };
-}
-export interface StatusLineSettings {
-    preset?: StatusLinePreset;
-    leftSegments?: StatusLineSegmentId[];
-    rightSegments?: StatusLineSegmentId[];
-    separator?: StatusLineSeparatorStyle;
-    segmentOptions?: StatusLineSegmentOptions;
-    previewHighlightSegment?: StatusLineSegmentId;
-    showHookStatus?: boolean;
-    showSkillHud?: boolean;
-    sessionAccent?: boolean;
-    maxRows?: number;
-}
-export interface StatusLineComponentOptions {
-    version?: string;
-}
-export declare class StatusLineComponent implements Component {
-    #private;
-    private readonly session;
-    constructor(session: AgentSession, options?: StatusLineComponentOptions);
-    updateSettings(settings: StatusLineSettings): void;
-    setAutoCompactEnabled(enabled: boolean): void;
-    setSubagentCount(count: number): void;
-    setJobs(jobs: JobsSnapshot): void;
-    setSessionStartTime(time: number): void;
-    setPlanModeStatus(status: {
-        enabled: boolean;
-        paused: boolean;
-    } | undefined): void;
-    setGoalModeStatus(status: {
-        enabled: boolean;
-        paused: boolean;
-    } | undefined): void;
-    setSkillHudEntriesForTest(entries: SkillActiveEntry[]): void;
-    setHookStatus(key: string, text: string | undefined): void;
-    watchBranch(onBranchChange: () => void): void;
-    dispose(): void;
-    invalidate(): void;
-    /**
-     * Background-refresh the OAuth quota report. Guarded by a 5-min TTL on both
-     * success (cache lifetime) and error (backoff). Exposed (non-private) so
-     * unit tests can verify the backoff invariant.
-     */
-    refreshUsageInBackground(): void;
-    getTopBorder(width: number): {
-        content: string;
-        width: number;
-    };
-    /**
-     * Multi-row-aware content for the settings preview: the wrapped rows joined
-     * with newlines so a single `Text` renders them stacked. Honors the current
-     * `maxRows`; identical to the single status line when `maxRows` is 1 or when
-     * everything fits on one row.
-     */
-    getPreviewContent(width: number): string;
-    getCacheStatsForTest(): {
-        rowHits: number;
-        rowMisses: number;
-    };
-    invalidateBranchForTest(): void;
-    setCachedPrForTest(pr: {
-        number: number;
-        url: string;
-    } | null): void;
-    render(width: number): string[];
-}
+export * from "./tool-status-header";

package/dist/types/modes/components/tasks-pane.d.ts

@@ -0,0 +1,15 @@
+import { Container, type SelectItem, SelectList } from "@gajae-code/tui";
+import type { TaskRow, TasksAggregator } from "../tasks-aggregator";
+export interface TasksPaneCallbacks {
+    close(): void;
+    requestRender(): void;
+}
+/** A compact, read-only unified task list. Source-specific controls remain in their owners. */
+export declare class TasksPaneComponent extends Container {
+    #private;
+    constructor(aggregator: TasksAggregator, callbacks: TasksPaneCallbacks);
+    getFocus(): SelectList;
+    handleInput(data: string): void;
+    refresh(): void;
+}
+export declare function taskItem(row: TaskRow): SelectItem;

package/dist/types/modes/components/theme-selector.d.ts

@@ -1,4 +1,4 @@
-import { Container, SelectList } from "@gajae-code/tui";
+import { Container, type SelectList } from "@gajae-code/tui";
 /**
  * Component that renders a theme selector.
  * Themes must be pre-loaded and passed to the constructor.

package/dist/types/modes/components/tool-execution.d.ts

@@ -20,6 +20,15 @@ export interface ToolExecutionHandle {
     }, isPartial?: boolean, toolCallId?: string): void;
     setArgsComplete(toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
+    /**
+     * Applies an explicit fold choice for this renderer instance. The pin lasts
+     * only for this instance; transcript rebuilds recreate it from global state.
+     * Optional for source compatibility: this interface is publicly exported and
+     * pre-existing structural implementers must keep compiling. Dispatchers must
+     * guard with `typeof handle.setManuallyExpanded === "function"` and fall
+     * back to {@link setExpanded}.
+     */
+    setManuallyExpanded?(expanded: boolean): void;
 }
 /**
  * Component that renders a tool call with its result (updateable)
@@ -48,7 +57,13 @@ export declare class ToolExecutionComponent extends Container {
      */
     stopAnimation(): void;
     dispose(): void;
+    /** Applies automatic expansion unless this renderer instance has an explicit fold choice. */
     setExpanded(expanded: boolean): void;
+    /**
+     * Applies and pins an explicit fold choice for this renderer instance only.
+     * Transcript rebuilds recreate components from global state and drop this pin.
+     */
+    setManuallyExpanded(expanded: boolean): void;
     setShowImages(show: boolean): void;
     invalidate(): void;
     render(width: number): string[];

package/dist/types/modes/components/tool-status-header.d.ts

@@ -0,0 +1,111 @@
+import { type Component } from "@gajae-code/tui";
+import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
+import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
+import type { AgentSession } from "../../session/agent-session";
+import { type SkillActiveEntry } from "../../skill-state/active-state";
+import type { ActionRegistry, FocusDomain } from "../action-registry";
+import { type JobsSnapshot } from "../jobs-observer";
+export interface StatusLineSegmentOptions {
+    model?: {
+        showThinkingLevel?: boolean;
+        showContextPercent?: boolean;
+    };
+    path?: {
+        abbreviate?: boolean;
+        maxLength?: number;
+        stripWorkPrefix?: boolean;
+    };
+    git?: {
+        showBranch?: boolean;
+        showStaged?: boolean;
+        showUnstaged?: boolean;
+        showUntracked?: boolean;
+    };
+    time?: {
+        format?: "12h" | "24h";
+        showSeconds?: boolean;
+    };
+    usage?: {
+        mode?: "used" | "remaining";
+    };
+}
+export interface StatusLineSettings {
+    preset?: StatusLinePreset;
+    leftSegments?: StatusLineSegmentId[];
+    rightSegments?: StatusLineSegmentId[];
+    separator?: StatusLineSeparatorStyle;
+    segmentOptions?: StatusLineSegmentOptions;
+    previewHighlightSegment?: StatusLineSegmentId;
+    showHookStatus?: boolean;
+    showSkillHud?: boolean;
+    sessionAccent?: boolean;
+    maxRows?: number;
+}
+export interface StatusLineComponentOptions {
+    version?: string;
+    actionRegistry?: ActionRegistry<void>;
+    getKeybindings?: () => KeybindingsManager;
+    focusDomain?: FocusDomain;
+}
+export interface StatusLineActionHint {
+    id: AppKeybinding;
+    content: string;
+}
+/**
+ * Produces whole, bound action hints for the current focus domain. The registry
+ * remains the authority for availability; KEYBINDINGS remains the authority for
+ * whether an action has a binding and the active manager supplies overrides.
+ */
+export declare function getAvailableActionHints(actionRegistry: ActionRegistry<void> | undefined, getKeybindings: (() => KeybindingsManager) | undefined, width: number, domain?: FocusDomain): StatusLineActionHint[];
+export declare class StatusLineComponent implements Component {
+    #private;
+    private readonly session;
+    constructor(session: AgentSession, options?: StatusLineComponentOptions);
+    updateSettings(settings: StatusLineSettings): void;
+    setActionRegistry(actionRegistry: ActionRegistry<void>, getKeybindings: () => KeybindingsManager): void;
+    setFocusDomain(domain: FocusDomain): void;
+    setAutoCompactEnabled(enabled: boolean): void;
+    setSubagentCount(count: number): void;
+    setJobs(jobs: JobsSnapshot): void;
+    setSessionStartTime(time: number): void;
+    setPlanModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setGoalModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+    setSkillHudEntriesForTest(entries: SkillActiveEntry[]): void;
+    setHookStatus(key: string, text: string | undefined): void;
+    watchBranch(onBranchChange: () => void): void;
+    dispose(): void;
+    invalidate(): void;
+    /**
+     * Background-refresh the OAuth quota report. Guarded by a 5-min TTL on both
+     * success (cache lifetime) and error (backoff). Exposed (non-private) so
+     * unit tests can verify the backoff invariant.
+     */
+    refreshUsageInBackground(): void;
+    getTopBorder(width: number): {
+        content: string;
+        width: number;
+    };
+    /**
+     * Multi-row-aware content for the settings preview: the wrapped rows joined
+     * with newlines so a single `Text` renders them stacked. Honors the current
+     * `maxRows`; identical to the single status line when `maxRows` is 1 or when
+     * everything fits on one row.
+     */
+    getPreviewContent(width: number): string;
+    getCacheStatsForTest(): {
+        rowHits: number;
+        rowMisses: number;
+    };
+    invalidateBranchForTest(): void;
+    setCachedPrForTest(pr: {
+        number: number;
+        url: string;
+    } | null): void;
+    render(width: number): string[];
+}

package/dist/types/modes/components/transcript-viewer-overlay.d.ts

@@ -0,0 +1,42 @@
+import { Container, type MouseEvent } from "@gajae-code/tui";
+import type { TranscriptItemRegistry, TranscriptSourcePayload } from "../transcript-item-registry";
+export type TranscriptViewerEntry = {
+    id: string;
+    kind: string;
+    label?: string;
+    payload: TranscriptSourcePayload;
+    copyable?: boolean;
+    foldable?: boolean;
+    rawViewable?: boolean;
+    getDisplayText?: (expanded: boolean) => string;
+};
+export type TranscriptViewerOverlayOptions = {
+    title?: string;
+    getEntries: () => readonly TranscriptViewerEntry[];
+    onClose: () => void;
+    requestRender?: () => void;
+    copyToClipboard?: (text: string) => void;
+    onError?: (message: string) => void;
+    enterExpands?: boolean;
+    initialSelection?: "first" | "latest";
+    followTail?: boolean;
+    getHeaderLines?: () => readonly string[];
+    getFooterLines?: () => readonly string[];
+    maxExpandedLines?: number;
+    footerControls?: string;
+    getEntryText?: (entry: TranscriptViewerEntry, expanded: boolean) => string;
+};
+/** Message-agnostic, modal transcript browser over resolved projection entries. */
+export declare class TranscriptViewerOverlay extends Container {
+    #private;
+    constructor(options: TranscriptViewerOverlayOptions);
+    get selectedEntryId(): string | undefined;
+    get isFullscreen(): boolean;
+    refresh(identityMap?: ReadonlyMap<string, string>): void;
+    render(width: number): string[];
+    handleMouse(event: MouseEvent): void;
+    handleInput(keyData: string): void;
+    resetSourceState(): void;
+}
+/** Main-session adapter over the registry's canonical payload resolver. */
+export declare function transcriptViewerEntries(registry: TranscriptItemRegistry): TranscriptViewerEntry[];

package/dist/types/modes/controllers/goal-mode-controller.d.ts

@@ -0,0 +1,62 @@
+import { type Goal } from "../../goals/state";
+import type { AgentSession, AgentSessionEvent } from "../../session/agent-session";
+import type { SessionContext, SessionManager } from "../../session/session-manager";
+import type { SubmittedUserInput } from "../types";
+import type { ModeGate } from "./mode-gate";
+interface GoalModeControllerContext {
+    readonly session: AgentSession;
+    readonly sessionManager: SessionManager;
+    readonly modeGate: ModeGate;
+    get planModeActive(): boolean;
+    get inputCallback(): ((input: SubmittedUserInput) => void) | undefined;
+    get hasPendingSubmission(): boolean;
+    get hasPendingImages(): boolean;
+    get editorText(): string;
+    startPendingSubmission(input: {
+        text: string;
+        customType?: string;
+        display?: boolean;
+    }): SubmittedUserInput;
+    showStatus(message: string): void;
+    showWarning(message: string): void;
+    showError(message: string): void;
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showHookSelector(title: string, options: string[]): Promise<string | undefined>;
+    showHookEditor(title: string, options?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    updateGoalModeStatus(status: {
+        enabled: boolean;
+        paused: boolean;
+    } | undefined): void;
+}
+/** Owns goal-mode state, continuation scheduling, commands, and session restoration. */
+export declare class GoalModeController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: GoalModeControllerContext);
+    get enabled(): boolean;
+    get paused(): boolean;
+    setEnabledForCompatibility(enabled: boolean): void;
+    setPausedForCompatibility(paused: boolean): void;
+    beforeGetUserInput(): Promise<void>;
+    scheduleContinuation(): void;
+    cancelContinuation(): void;
+    onPendingSubmissionFinished(customType?: string): void;
+    onUserSubmission(): void;
+    handleSessionEvent(event: AgentSessionEvent): Promise<void>;
+    restoreFromSession(sessionContext: SessionContext): Promise<boolean>;
+    handleCommand(rest?: string): Promise<void>;
+    enter(options: {
+        objective?: string;
+        provenance?: Goal["provenance"];
+        resume?: boolean;
+        silent?: boolean;
+    }): Promise<void>;
+    exit(options?: {
+        silent?: boolean;
+        paused?: boolean;
+        reason?: "completed" | "paused" | "dropped";
+    }): Promise<void>;
+}
+export {};

package/dist/types/modes/controllers/input-controller.d.ts

@@ -1,14 +1,21 @@
 import { type AutocompleteProvider, type SlashCommand } from "@gajae-code/tui";
-import type { InteractiveModeContext } from "../../modes/types";
+import { type ComposerSubmissionOptions, type InteractiveModeContext } from "../../modes/types";
+import { ActionRegistry } from "../action-registry";
+export declare const INTERACTIVE_ABORT_CLEANUP_TIMEOUT_MS = 5000;
+export declare const BACKGROUND_FOLD_DOUBLE_PRESS_MS = 750;
 export declare class InputController {
     #private;
     private ctx;
+    readonly actionRegistry: ActionRegistry<void>;
     constructor(ctx: InteractiveModeContext);
     setupKeyHandlers(): void;
     setupEditorSubmitHandler(): void;
+    submitText(text: string, composer: ComposerSubmissionOptions): Promise<void>;
     handleCtrlC(): void;
     handleCtrlD(): void;
     handleCtrlZ(): void;
+    toggleQueuePane(): void;
+    sendNow(): Promise<void>;
     handleDequeue(): void;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;

package/dist/types/modes/controllers/mode-gate.d.ts

@@ -0,0 +1,8 @@
+export type ExclusiveMode = "goal" | "plan";
+/** Owns the mutual-exclusion state for interactive goal and plan modes. */
+export declare class ModeGate {
+    #private;
+    get activeMode(): ExclusiveMode | undefined;
+    enter(mode: ExclusiveMode): boolean;
+    exit(mode: ExclusiveMode): void;
+}