agent-afk 5.1.0 → 5.3.0

package/dist/cli/slash/writer.d.ts

@@ -0,0 +1,6 @@
+import type { Writer } from './types.js';
+export interface WriterSink {
+    fn: (line: string) => void;
+    rawFn?: (text: string) => void;
+}
+export declare function createConsoleWriter(sink?: WriterSink): Writer;

package/dist/cli/status-line.d.ts

@@ -0,0 +1,51 @@
+import type { PermissionMode } from '../agent/types/sdk-types.js';
+export interface StatusLineFields {
+    model: string;
+    cost?: number;
+    tokens?: number;
+    contextPct?: number;
+    contextLimit?: number;
+    contextUsedTokens?: number;
+    contextSparkline?: string;
+    permissionMode?: PermissionMode;
+    cwd?: string;
+    branch?: string;
+    pr?: number;
+}
+interface StatusLineOpts {
+    stream?: NodeJS.WriteStream;
+    force?: boolean;
+    throttleMs?: number;
+}
+export declare class StatusLine {
+    private readonly stream;
+    private readonly force;
+    private readonly throttleMs;
+    private started;
+    private lastRepaint;
+    private lastFields;
+    private resizeUnsub;
+    private resizeImmediateUnsub;
+    private lastPaintedRow;
+    private preResizePaintedRow;
+    private extraRows;
+    private afterScrollRestore;
+    constructor(opts?: StatusLineOpts);
+    private get enabled();
+    start(): void;
+    private resetGeometry;
+    private onResize;
+    repaint(fields: StatusLineFields): void;
+    flush(): void;
+    setExtraRows(n: number): void;
+    getExtraRows(): number;
+    setAfterScrollRestore(cb: (() => void) | null): void;
+    rearm(): void;
+    withFullScrollRegion<T>(fn: () => T): T;
+    stop(): void;
+    private formatLine;
+    private currentRows;
+    private paintRow;
+    private writeScrollRegion;
+}
+export {};

package/dist/cli/syntax-highlight.d.ts

@@ -0,0 +1 @@
+export declare function highlightCode(text: string, lang: string): string;

package/dist/cli/syntax-theme.d.ts

@@ -0,0 +1,2 @@
+import type { Sheet } from 'emphasize';
+export declare const defaultSyntaxTheme: Sheet;

package/dist/cli/terminal-compositor.autocomplete.d.ts

@@ -0,0 +1,16 @@
+import { type InputCoreState } from './input-core.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { SuggestContext, SuggestEngine } from './terminal-compositor.types.js';
+export declare const MAX_DROPDOWN_ROWS = 6;
+export interface AutocompleteHost {
+    readonly autocompleteState?: AutocompleteState;
+    input: InputCoreState;
+    activeGhost: string | null;
+    readonly ghostEngine: SuggestEngine | undefined;
+    readonly ghostGetContext: (() => SuggestContext) | undefined;
+    repaint(): void;
+}
+export declare function updateAutocomplete(self: AutocompleteHost): void;
+export declare function updateGhost(self: AutocompleteHost): void;
+export declare function applyDropdownSelection(self: AutocompleteHost): boolean;
+export declare function applyGhostAccept(self: AutocompleteHost): boolean;

package/dist/cli/terminal-compositor.committed-band-commit.d.ts

@@ -0,0 +1,24 @@
+import type { LogUpdateFn, CompositorScrollRegionGuard } from './terminal-compositor.types.js';
+export interface CommittedBandHost {
+    repaint(): void;
+    debugLog(stage: string, extra?: Record<string, unknown>): void;
+    committedBand: string[];
+    committedBandTopRow: number;
+    committedBandBottomRow: number;
+    committedBandPaintedRows: number;
+    committing: boolean;
+    commitInFlight: boolean;
+    hasCommitted: boolean;
+    pendingResizeErase: {
+        top: number;
+        bottom: number;
+    } | null;
+    anchorRow: number | undefined;
+    armed: boolean;
+    logUpdate: LogUpdateFn | null;
+    readonly scrollRegion?: CompositorScrollRegionGuard;
+    readonly stdout: NodeJS.WriteStream;
+}
+export declare function commitAbove(self: CommittedBandHost, text: string): void;
+export declare function clearCommittedBand(self: CommittedBandHost): void;
+export declare function resetCommittedBand(self: CommittedBandHost): void;

package/dist/cli/terminal-compositor.committed-band-repin.d.ts

@@ -0,0 +1,3 @@
+import type { CommittedBandHost } from './terminal-compositor.committed-band-commit.js';
+export declare function flushResizeGhostErase(self: CommittedBandHost): void;
+export declare function repositionCommittedBand(self: CommittedBandHost, desiredTopRow: number, preRenderFrameTop: number, targetBottomRow: number): void;

package/dist/cli/terminal-compositor.committed-band.d.ts

@@ -0,0 +1,2 @@
+export * from './terminal-compositor.committed-band-commit.js';
+export * from './terminal-compositor.committed-band-repin.js';

package/dist/cli/terminal-compositor.d.ts

@@ -0,0 +1,118 @@
+import { type InputCoreState } from './input-core.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { IHistoryRing } from './input/types.js';
+import type { ImageAttachment } from './input/attachments.js';
+import { SpinnerController } from './input/spinner.js';
+import { CaretBlinkController } from './input/caret-blink.js';
+import type { StdinClaimHandle } from './input/stdin-claim.js';
+import { type CompositorInputMode, type CompositorScrollRegionGuard, type KeyInfo, type LogUpdateFn, type PickerController, type SubmissionPayload, type TerminalCompositorOptions, type SuggestEngine, type SuggestContext } from './terminal-compositor.types.js';
+export type { CompositorInputMode, CompositorScrollRegionGuard, PickerController, SubmissionPayload, SuggestContext, SuggestEngine, TerminalCompositorOptions, };
+export declare class TerminalCompositor {
+    readonly stdout: NodeJS.WriteStream;
+    readonly stdin: NodeJS.ReadStream;
+    onCancel?: () => void;
+    onSoftStop?: () => void;
+    softStopped: boolean;
+    onBackground?: () => void;
+    onPauseInterrupt?: () => void;
+    onShiftTab?: () => void;
+    readonly promptTextFn: () => string;
+    readonly history?: IHistoryRing;
+    readonly autocompleteState?: AutocompleteState;
+    readonly formatInputBuffer?: (segment: string) => string;
+    readonly scrollRegion?: CompositorScrollRegionGuard;
+    anchorRow: number | undefined;
+    declaredAnchorRow: number | undefined;
+    onSubmit?: (payload: SubmissionPayload) => void;
+    attachments: ImageAttachment[];
+    pasting: boolean;
+    pasteStartBufferLen: number;
+    pasteStartCursor: number;
+    pasteRegistry: Map<string, string>;
+    clipboardInFlight: boolean;
+    clipboardFailureMsg: string | null;
+    inputMode: CompositorInputMode;
+    pickerController: PickerController | null;
+    pickerSavedMode: CompositorInputMode;
+    armed: boolean;
+    suspended: boolean;
+    canceled: boolean;
+    backgrounded: boolean;
+    paused: boolean;
+    wasRaw: boolean;
+    stdinClaim: StdinClaimHandle | null;
+    logUpdate: LogUpdateFn | null;
+    overlay: string;
+    input: InputCoreState;
+    queued: boolean;
+    pendingSubmissions: SubmissionPayload[];
+    handleKeypress: ((char: string | undefined, key: KeyInfo) => void) | null;
+    resizeUnsub: (() => void) | null;
+    resizeImmediateUnsub: (() => void) | null;
+    readonly spinnerController: SpinnerController;
+    readonly caretBlinkController: CaretBlinkController;
+    repaintCount: number;
+    committing: boolean;
+    hasCommitted: boolean;
+    committedBand: string[];
+    committedBandTopRow: number;
+    committedBandBottomRow: number;
+    committedBandPaintedRows: number;
+    lastKnownRows: number;
+    pendingResizeErase: {
+        top: number;
+        bottom: number;
+    } | null;
+    commitInFlight: boolean;
+    private readonly debugCompositor;
+    readonly ghostEngine: SuggestEngine | undefined;
+    readonly ghostGetContext: (() => SuggestContext) | undefined;
+    activeGhost: string | null;
+    debugLog(stage: string, extra?: Record<string, unknown>): void;
+    constructor(opts: TerminalCompositorOptions);
+    isArmed(): boolean;
+    setAnchorRow(row: number | undefined): void;
+    suspendInput(): void;
+    resumeInput(): void;
+    setOnSubmit(handler: ((payload: SubmissionPayload) => void) | null): void;
+    setOnCancel(handler: (() => void) | null): void;
+    getOnCancel(): (() => void) | undefined;
+    setOnSoftStop(handler: (() => void) | null): void;
+    setOnBackground(handler: (() => void) | null): void;
+    setOnShiftTab(handler: (() => void) | null): void;
+    enterPickerMode(controller: PickerController): void;
+    exitPickerMode(): void;
+    repaintPicker(): void;
+    setInputMode(mode: CompositorInputMode): void;
+    getInputMode(): CompositorInputMode;
+    arm(): Promise<void>;
+    disarm(): void;
+    setOverlay(text: string): void;
+    setSpinner(config: {
+        enabled: boolean;
+        rotateVerbEveryMs?: number;
+    }): void;
+    commitAbove(text: string): void;
+    clearCommittedBand(): void;
+    flushResizeGhostErase(): void;
+    resetCommittedBand(): void;
+    repositionCommittedBand(desiredTopRow: number, preRenderFrameTop: number, targetBottomRow: number): void;
+    getBuffer(): {
+        text: string;
+        queued: boolean;
+    };
+    getPendingCount(): number;
+    getAttachments(): ImageAttachment[];
+    get caretVisible(): boolean;
+    renderInputLine(): string;
+    updateAutocomplete(): void;
+    updateGhost(): void;
+    renderDropdownRows(): string[];
+    renderHintRow(): string | null;
+    repaint(): void;
+    clearScreen(): void;
+    resetState(): void;
+    applyEdit(next: InputCoreState): boolean;
+    applyDropdownSelection(): boolean;
+    applyGhostAccept(): boolean;
+}

package/dist/cli/terminal-compositor.frame-preserve.d.ts

@@ -0,0 +1,3 @@
+import type { FrameHost } from './terminal-compositor.frame.js';
+export declare function preserveRowsBeforeFrameRender(self: FrameHost, desiredTopRow: number): void;
+export declare function evictRowsToScrollback(self: FrameHost, rows: number): void;

package/dist/cli/terminal-compositor.frame.d.ts

@@ -0,0 +1,33 @@
+import { type ImageAttachment } from './input/attachments.js';
+import type { SpinnerController } from './input/spinner.js';
+import type { CompositorInputMode, CompositorScrollRegionGuard, LogUpdateFn, PickerController } from './terminal-compositor.types.js';
+export interface FrameHost {
+    flushResizeGhostErase(): void;
+    renderInputLine(): string;
+    renderDropdownRows(): string[];
+    renderHintRow(): string | null;
+    repositionCommittedBand(desiredTopRow: number, preRenderFrameTop: number, targetBottomRow: number): void;
+    clearCommittedBand(): void;
+    debugLog(stage: string, extra?: Record<string, unknown>): void;
+    armed: boolean;
+    committing: boolean;
+    suspended: boolean;
+    logUpdate: LogUpdateFn | null;
+    overlay: string;
+    inputMode: CompositorInputMode;
+    pickerController: PickerController | null;
+    readonly spinnerController: SpinnerController;
+    attachments: ImageAttachment[];
+    clipboardFailureMsg: string | null;
+    committedBand: string[];
+    committedBandTopRow: number;
+    committedBandBottomRow: number;
+    committedBandPaintedRows: number;
+    hasCommitted: boolean;
+    anchorRow: number | undefined;
+    lastKnownRows: number;
+    commitInFlight: boolean;
+    readonly scrollRegion?: CompositorScrollRegionGuard;
+    readonly stdout: NodeJS.WriteStream;
+}
+export declare function repaint(self: FrameHost): void;

package/dist/cli/terminal-compositor.input-dispatch.d.ts

@@ -0,0 +1,42 @@
+import { type InputCoreState } from './input-core.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { IHistoryRing } from './input/types.js';
+import type { ImageAttachment } from './input/attachments.js';
+import type { CompositorInputMode, KeyInfo, PickerController, SubmissionPayload } from './terminal-compositor.types.js';
+export interface KeyDispatchHost {
+    repaint(): void;
+    clearScreen(): void;
+    applyEdit(next: InputCoreState): boolean;
+    updateAutocomplete(): void;
+    updateGhost(): void;
+    applyDropdownSelection(): boolean;
+    applyGhostAccept(): boolean;
+    readonly armed: boolean;
+    input: InputCoreState;
+    queued: boolean;
+    pendingSubmissions: SubmissionPayload[];
+    readonly inputMode: CompositorInputMode;
+    readonly pickerController: PickerController | null;
+    pasting: boolean;
+    pasteStartBufferLen: number;
+    pasteStartCursor: number;
+    readonly pasteRegistry: Map<string, string>;
+    clipboardInFlight: boolean;
+    clipboardFailureMsg: string | null;
+    attachments: ImageAttachment[];
+    readonly autocompleteState?: AutocompleteState;
+    readonly activeGhost: string | null;
+    readonly history?: IHistoryRing;
+    softStopped: boolean;
+    canceled: boolean;
+    backgrounded: boolean;
+    paused: boolean;
+    readonly onCancel?: () => void;
+    readonly onSoftStop?: () => void;
+    readonly onBackground?: () => void;
+    readonly onPauseInterrupt?: () => void;
+    readonly onShiftTab?: () => void;
+    readonly onSubmit?: (payload: SubmissionPayload) => void;
+}
+export declare function applyEdit(self: KeyDispatchHost, next: InputCoreState): boolean;
+export declare function dispatchKey(self: KeyDispatchHost, char: string | undefined, key: KeyInfo): void;

package/dist/cli/terminal-compositor.input-mode.d.ts

@@ -0,0 +1,26 @@
+import { type InputCoreState } from './input-core.js';
+import type { ImageAttachment } from './input/attachments.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { CompositorInputMode, PickerController, SubmissionPayload } from './terminal-compositor.types.js';
+export interface InputModeHost {
+    repaint(): void;
+    inputMode: CompositorInputMode;
+    pickerSavedMode: CompositorInputMode;
+    pickerController: PickerController | null;
+    readonly autocompleteState?: AutocompleteState;
+    softStopped: boolean;
+    canceled: boolean;
+    backgrounded: boolean;
+    queued: boolean;
+    pendingSubmissions: SubmissionPayload[];
+    input: InputCoreState;
+    attachments: ImageAttachment[];
+    readonly pasteRegistry: Map<string, string>;
+    readonly pasteStartCursor: number;
+    readonly onSubmit?: (payload: SubmissionPayload) => void;
+}
+export declare function enterPickerMode(self: InputModeHost, controller: PickerController): void;
+export declare function exitPickerMode(self: InputModeHost): void;
+export declare function repaintPicker(self: InputModeHost): void;
+export declare function setInputMode(self: InputModeHost, mode: CompositorInputMode): void;
+export declare function getInputMode(self: InputModeHost): CompositorInputMode;

package/dist/cli/terminal-compositor.lifecycle.d.ts

@@ -0,0 +1,40 @@
+import { type StdinClaimHandle } from './input/stdin-claim.js';
+import type { SpinnerController } from './input/spinner.js';
+import type { CaretBlinkController } from './input/caret-blink.js';
+import type { SuggestEngine } from './terminal-compositor.types.js';
+import type { CompositorScrollRegionGuard, KeyInfo, LogUpdateFn } from './terminal-compositor.types.js';
+import type { KeyDispatchHost } from './terminal-compositor.input-dispatch.js';
+export interface LifecycleHost {
+    repaint(): void;
+    resetState(): void;
+    readonly repaintCount: number;
+    readonly stdout: NodeJS.WriteStream;
+    readonly stdin: NodeJS.ReadStream;
+    armed: boolean;
+    suspended: boolean;
+    wasRaw: boolean;
+    stdinClaim: StdinClaimHandle | null;
+    handleKeypress: ((char: string | undefined, key: KeyInfo) => void) | null;
+    resizeUnsub: (() => void) | null;
+    resizeImmediateUnsub: (() => void) | null;
+    logUpdate: LogUpdateFn | null;
+    readonly scrollRegion?: CompositorScrollRegionGuard;
+    anchorRow: number | undefined;
+    declaredAnchorRow: number | undefined;
+    canceled: boolean;
+    readonly spinnerController: SpinnerController;
+    readonly caretBlinkController: CaretBlinkController;
+    readonly ghostEngine: SuggestEngine | undefined;
+    lastKnownRows: number;
+    pendingResizeErase: {
+        top: number;
+        bottom: number;
+    } | null;
+    readonly committedBand: string[];
+    readonly committedBandTopRow: number;
+    readonly committedBandPaintedRows: number;
+}
+export declare function suspendInput(self: LifecycleHost): void;
+export declare function resumeInput(self: LifecycleHost): void;
+export declare function arm(self: LifecycleHost & KeyDispatchHost): Promise<void>;
+export declare function disarm(self: LifecycleHost): void;

package/dist/cli/terminal-compositor.paste.d.ts

@@ -0,0 +1,16 @@
+import { type InputCoreState } from './input-core.js';
+export interface PasteHost {
+    readonly pasteRegistry: Map<string, string>;
+    readonly pasteStartCursor: number;
+    input: InputCoreState;
+}
+export declare function expandPastePlaceholders(self: PasteHost, buffer: string): string;
+export interface BufferSnapshotHost extends PasteHost {
+    readonly queued: boolean;
+}
+export declare function getBuffer(self: BufferSnapshotHost): {
+    text: string;
+    queued: boolean;
+};
+export declare function maybeTruncatePaste(self: PasteHost): void;
+export declare function maybeAtomicPlaceholderDelete(self: PasteHost, direction: 'backward' | 'forward'): InputCoreState | null;

package/dist/cli/terminal-compositor.render.d.ts

@@ -0,0 +1,17 @@
+import type { InputCoreState } from './input-core.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { SubmissionPayload } from './terminal-compositor.types.js';
+export interface RenderHost {
+    readonly queued: boolean;
+    readonly pendingSubmissions: readonly SubmissionPayload[];
+    readonly input: InputCoreState;
+    readonly caretVisible?: boolean;
+    readonly activeGhost: string | null;
+    readonly autocompleteState?: AutocompleteState;
+    readonly formatInputBuffer?: (segment: string) => string;
+    readonly promptTextFn: () => string;
+    readonly stdout: NodeJS.WriteStream;
+}
+export declare function renderInputLine(self: RenderHost): string;
+export declare function renderDropdownRows(self: RenderHost): string[];
+export declare function renderHintRow(self: RenderHost): string | null;

package/dist/cli/terminal-compositor.reset.d.ts

@@ -0,0 +1,36 @@
+import { type InputCoreState } from './input-core.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { ImageAttachment } from './input/attachments.js';
+import type { CompositorInputMode, PickerController, SubmissionPayload } from './terminal-compositor.types.js';
+export interface ResetStateHost {
+    clearCommittedBand(): void;
+    overlay: string;
+    input: InputCoreState;
+    queued: boolean;
+    pendingSubmissions: SubmissionPayload[];
+    canceled: boolean;
+    backgrounded: boolean;
+    softStopped: boolean;
+    paused: boolean;
+    activeGhost: string | null;
+    anchorRow: number | undefined;
+    hasCommitted: boolean;
+    commitInFlight: boolean;
+    pendingResizeErase: {
+        top: number;
+        bottom: number;
+    } | null;
+    lastKnownRows: number;
+    pickerController: PickerController | null;
+    inputMode: CompositorInputMode;
+    attachments: ImageAttachment[];
+    pasting: boolean;
+    pasteStartBufferLen: number;
+    pasteStartCursor: number;
+    readonly pasteRegistry: Map<string, string>;
+    clipboardFailureMsg: string | null;
+    readonly autocompleteState?: AutocompleteState;
+    resizeUnsub: (() => void) | null;
+    resizeImmediateUnsub: (() => void) | null;
+}
+export declare function resetState(self: ResetStateHost): void;

package/dist/cli/terminal-compositor.types.d.ts

@@ -0,0 +1,80 @@
+import type { LoadingTip } from './loading-tips.js';
+import type { ImageAttachment } from './input/attachments.js';
+import type { AutocompleteState } from './input/autocomplete-state.js';
+import type { IHistoryRing } from './input/types.js';
+import type { SuggestEngine, SuggestContext } from './input/suggest.js';
+export type { SuggestEngine, SuggestContext };
+export interface LogUpdateFn {
+    render: (content: string, targetBottomRow: number, anchorFloor?: number) => void;
+    clear: (extraRows?: number) => void;
+    done: () => void;
+    readonly topRow?: number;
+    resetGeometry?: () => void;
+    measure?: (content: string, targetBottomRow: number) => {
+        topRow: number;
+        lineCount: number;
+    };
+}
+export interface KeyInfo {
+    name?: string;
+    sequence?: string;
+    ctrl?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+}
+export declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export declare const ELAPSED_GRACE_MS = 2000;
+export declare function formatElapsed(startedAt: number): string;
+export declare function eraseAndPaintRow(row: number, line?: string): string;
+export declare function formatTipRow(text: string, cols: number): string;
+export interface SpinnerState {
+    frameIndex: number;
+    verb: string;
+    nextVerbRotateAt: number;
+    startedAt: number;
+    tipPool: readonly LoadingTip[];
+    currentTip: LoadingTip | null;
+}
+export interface CompositorScrollRegionGuard {
+    withFullScrollRegion<T>(fn: () => T): T;
+    getExtraRows(): number;
+}
+export type CompositorInputMode = 'idle' | 'streaming' | 'picker';
+export interface PickerController {
+    renderRows: () => readonly string[];
+    onKey: (char: string | undefined, key: {
+        name?: string;
+        ctrl?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+        sequence?: string;
+    }) => void;
+}
+export interface SubmissionPayload {
+    text: string;
+    displayText?: string;
+    attachments: readonly ImageAttachment[];
+}
+export interface TerminalCompositorOptions {
+    stdout: NodeJS.WriteStream;
+    stdin: NodeJS.ReadStream;
+    onCancel?: () => void;
+    onSoftStop?: () => void;
+    onBackground?: () => void;
+    onPauseInterrupt?: () => void;
+    onShiftTab?: () => void;
+    onSubmit?: (payload: SubmissionPayload) => void;
+    promptText?: string | (() => string);
+    history?: IHistoryRing;
+    autocompleteState?: AutocompleteState;
+    formatInputBuffer?: (segment: string) => string;
+    scrollRegion?: CompositorScrollRegionGuard;
+    captureMode?: boolean;
+    caretBlink?: boolean;
+    caretBlinkIntervalMs?: number;
+    anchorRow?: number;
+    suggest?: {
+        engine: SuggestEngine;
+        getContext: () => SuggestContext;
+    };
+}

package/dist/cli/terminal-size.d.ts

@@ -0,0 +1,9 @@
+export declare function getTerminalWidth(): number;
+export declare function getTerminalHeight(): number;
+export declare function subscribeResize(fn: () => void): () => void;
+export declare function subscribeResizeImmediate(fn: () => void): () => void;
+export declare function __flushResizeBusForTests(): void;
+export declare const ResizeBus: {
+    readonly subscribe: typeof subscribeResize;
+    readonly subscribeImmediate: typeof subscribeResizeImmediate;
+};

package/dist/cli/terminal-spawn/detect.d.ts

@@ -0,0 +1,3 @@
+export type TerminalKind = 'tmux' | 'wezterm' | 'kitty' | 'iterm2' | 'apple-terminal' | 'ghostty' | 'windows-terminal' | 'gnome-terminal' | 'konsole' | 'vscode' | 'alacritty' | 'hyper' | 'unknown';
+export type SpawnCapability = 'tab' | 'window' | 'none';
+export declare function detectTerminal(env?: NodeJS.ProcessEnv): TerminalKind;

package/dist/cli/terminal-spawn/index.d.ts

@@ -0,0 +1,29 @@
+import { type SpawnCapability, type TerminalKind } from './detect.js';
+import type { AgentModelInput } from '../../agent/types.js';
+export interface SpawnOutcome {
+    spawned: boolean;
+    kind: TerminalKind;
+    capability: SpawnCapability;
+    reason?: string;
+}
+export type RunFn = (cmd: string, args: string[], options: {
+    stdio: 'ignore';
+    timeout: number;
+}) => {
+    status: number | null;
+    error?: Error;
+};
+export interface TrySpawnOptions {
+    forkId: string;
+    model: AgentModelInput;
+    cwd: string;
+    interactive: boolean;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    run?: RunFn;
+}
+export declare function trySpawnTab(opts: TrySpawnOptions): SpawnOutcome;
+export { detectTerminal } from './detect.js';
+export type { TerminalKind, SpawnCapability } from './detect.js';
+export { planSpawn, resolveResumeInvocation } from './spawners.js';
+export type { SpawnPlan, ResumeInvocation } from './spawners.js';

package/dist/cli/terminal-spawn/spawners.d.ts

@@ -0,0 +1,18 @@
+import type { AgentModelInput } from '../../agent/types.js';
+import type { SpawnCapability, TerminalKind } from './detect.js';
+export interface ResumeInvocation {
+    argv: string[];
+    shellCommand: string;
+    cwd: string;
+    spawnable: boolean;
+}
+export interface SpawnPlan {
+    kind: TerminalKind;
+    capability: SpawnCapability;
+    exec?: {
+        cmd: string;
+        args: string[];
+    };
+}
+export declare function resolveResumeInvocation(forkId: string, model: AgentModelInput, cwd: string): ResumeInvocation;
+export declare function planSpawn(kind: TerminalKind, inv: ResumeInvocation, platform?: NodeJS.Platform): SpawnPlan;

package/dist/cli/todo-panel.d.ts

@@ -0,0 +1,18 @@
+export interface TodoItem {
+    id: number;
+    text: string;
+    done: boolean;
+    createdAt: number;
+}
+export interface TodoStore {
+    sessionId: string;
+    items: TodoItem[];
+}
+export declare function loadTodos(sessionId: string): TodoStore;
+export declare function saveTodos(store: TodoStore): void;
+export declare function addTodo(store: TodoStore, text: string): TodoItem;
+export declare function markDone(store: TodoStore, id: number): TodoItem | undefined;
+export declare function removeTodo(store: TodoStore, id: number): boolean;
+export declare function clearTodos(store: TodoStore): void;
+export declare function renderTodoPanel(store: TodoStore): string[];
+export declare function todoFingerprint(store: TodoStore): string;

package/dist/cli/tool-category.d.ts

@@ -0,0 +1,9 @@
+import { type ChalkInstance } from 'chalk';
+import { categorizeTool, dispatchTagForCategory, SUBAGENT_TOOLS, SKILL_TOOLS, DAG_TOOLS, NESTING_TOOLS, type ToolCategory } from '../agent/tool-category.js';
+export { categorizeTool, dispatchTagForCategory, SUBAGENT_TOOLS, SKILL_TOOLS, DAG_TOOLS, NESTING_TOOLS, type ToolCategory, };
+export interface CategoryStyle {
+    color: ChalkInstance;
+    glyph: string;
+}
+export declare function styleForCategory(cat: ToolCategory): CategoryStyle;
+export declare function styleForToolName(name: string): CategoryStyle;

package/dist/cli/trusted-skill-badge.d.ts

@@ -0,0 +1,19 @@
+import type { TrustedSkillResult } from '../agent/trusted-skill-result.js';
+export interface TrustedSkillRegistryEntry {
+    glyph: string;
+    color: string;
+    inFlightVerb: string;
+}
+export declare function registerTrustedSkill(name: string, entry: TrustedSkillRegistryEntry): void;
+export declare function clearRegistryForTesting(): void;
+export declare function getTrustedSkill(name: string): TrustedSkillRegistryEntry | undefined;
+export interface FormatTrustedSkillCompletionOpts {
+    isTTY?: boolean;
+    columns?: number;
+}
+export declare function formatTrustedSkillCompletion(result: TrustedSkillResult, opts?: FormatTrustedSkillCompletionOpts): string;
+export interface FormatTrustedSkillInFlightOpts {
+    isTTY?: boolean;
+    columns?: number;
+}
+export declare function formatTrustedSkillInFlight(skillName: string, opts?: FormatTrustedSkillInFlightOpts): string;