@slopus/happy-terminal 0.3.0-beta.13

package/dist/app/CodingAssistantAgentBackend.d.ts

@@ -0,0 +1,81 @@
+import type { AgentCompactionResult, AgentLoopEvent, AgentSnapshot, ContentBlock, GoalStatus, Message, Model, PermissionMode, ProviderError, SecretAttachmentScope, ServiceTier, SessionGoal, StopReason, UserMessage } from "../protocol/index.js";
+import type { Context } from "@steve.kite/stdlib";
+import type { AbortRunOptions, AbortRunResponse, GetSessionUsageResponse, ReadBackgroundProcessResponse, RunShellCommandResponse, SteerMessageResponse, SubmitContextMessageResponse, StopBackgroundProcessResponse } from "../protocol/index.js";
+export interface CodingAssistantClientProvider {
+    id: string;
+    models: readonly Model[];
+    serviceTiers?: readonly ServiceTier[];
+}
+export interface AgentRunOptions {
+    clientSubmissionId?: string;
+    displayText?: string;
+    onEvent?: (event: AgentLoopEvent) => void | Promise<void>;
+    onMessage?: (message: Message) => void | Promise<void>;
+    signal?: AbortSignal;
+}
+export interface AgentRunResult {
+    contextMessages: readonly Message[];
+    debugDirectory?: string;
+    errorMessage?: string;
+    messages: readonly Message[];
+    providerError?: ProviderError;
+    providerId?: string;
+    requestedModelId?: string;
+    runId: string;
+    stopReason: StopReason;
+}
+export interface CodingAssistantModelChoice {
+    model: Model;
+    providerId: string;
+}
+export interface SteeringRunOptions extends AgentRunOptions {
+    clientSubmissionId?: string;
+    expectedRunId?: string;
+}
+export interface CodingAssistantAgentBackend {
+    readonly canChangeModel: boolean;
+    readonly confirmedServiceTier: ServiceTier | undefined;
+    readonly id: string;
+    readonly provider: CodingAssistantClientProvider;
+    readonly model: Model;
+    readonly modelChoices?: readonly CodingAssistantModelChoice[];
+    readonly permissionMode: PermissionMode;
+    /** Unsent composer text shared with the other clients on this session. */
+    readonly draft?: string;
+    /** When that draft was typed, which decides who wins between clients. */
+    readonly draftUpdatedAt?: number | undefined;
+    readonly goal?: SessionGoal | undefined;
+    readonly projectSecretIds?: readonly string[];
+    readonly secretIds?: readonly string[];
+    readonly sessionSecretIds?: readonly string[];
+    getUsage?(): Promise<GetSessionUsageResponse>;
+    readBackgroundProcess(sessionId: number, options?: {
+        waitMs?: number;
+    }): Promise<ReadBackgroundProcessResponse | undefined>;
+    abort?(options?: AbortRunOptions): Promise<AbortRunResponse>;
+    attachSecret?(secretId: string, scope?: SecretAttachmentScope): Promise<void>;
+    compact(ctx: Context, signal?: AbortSignal, onEvent?: AgentRunOptions["onEvent"]): Promise<AgentCompactionResult>;
+    changeGoalStatus?(status: GoalStatus): Promise<void>;
+    clearGoal?(): Promise<void>;
+    detachSecret?(secretId: string, scope?: SecretAttachmentScope): Promise<void>;
+    reset(): Promise<void>;
+    runShellCommand(command: string, options: {
+        commandId: string;
+    }): Promise<RunShellCommandResponse>;
+    rewind?(messageId: string): Promise<UserMessage>;
+    stopBackgroundProcesses(): Promise<number>;
+    stopBackgroundProcess(sessionId: number): Promise<StopBackgroundProcessResponse>;
+    send(ctx: Context, content: string | readonly ContentBlock[], options?: AgentRunOptions): Promise<AgentRunResult>;
+    sendContext?(text: string): Promise<SubmitContextMessageResponse>;
+    steer(content: string | readonly ContentBlock[], options?: SteeringRunOptions): Promise<void | SteerMessageResponse>;
+    setEffort(effort: string | undefined): void;
+    setModel(modelId: string, effort: string | undefined, providerId?: string): void | Promise<void>;
+    setServiceTier(serviceTier: ServiceTier | undefined): void | Promise<void>;
+    setPermissionMode(mode: PermissionMode): void | Promise<void>;
+    setDraft?(draft: string, options?: {
+        origin?: string;
+        updatedAt?: number;
+    }): Promise<void>;
+    setGoal?(objective: string): Promise<void>;
+    snapshot(): AgentSnapshot;
+}

package/dist/app/CodingAssistantApp.d.ts

@@ -0,0 +1,128 @@
+import type { Context } from "@steve.kite/stdlib";
+import { type Component, type Focusable, type TUI } from "@earendil-works/pi-tui";
+import { type AgentLoopEvent, type AgentSnapshot, type Message, type BashSessionActivity, type GetSessionUsageResponse, type ServiceTier, type Usage, type UserInputRequest, type UserInputResponse } from "../protocol/index.js";
+import type { NativeProcessManager } from "../processes/index.js";
+import type { FileSearchResult, EventId, McpServerSummary, PresenceSnapshot, SecretSummary, SessionEvent, SessionTask, SubagentSummary, WorkflowRun } from "../protocol/index.js";
+import type { EnvironmentSecretRegistration, EnvironmentSecretUpdate, SecretAttachmentScope } from "../protocol/index.js";
+import type { CodingAssistantAgentBackend } from "./CodingAssistantAgentBackend.js";
+import { type ClipboardImage, type ReadClipboardImageOptions } from "./readClipboardImage.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+import type { StartupStatusCardModel } from "./StartupStatusCardModel.js";
+export type AppExitReason = "exit" | "reload";
+export interface CodingAssistantAppOptions {
+    engineVersion?: string;
+    activeAgentLabel?: string;
+    agent: CodingAssistantAgentBackend;
+    attachSecret?: (id: string, scope: SecretAttachmentScope) => void | Promise<void>;
+    cwd: string;
+    ctx: Context;
+    initialBackgroundProcesses?: readonly BashSessionActivity[];
+    initialUsage?: Usage;
+    initialMcpServers?: readonly McpServerSummary[];
+    /** Already persisted public API messages, oldest first. */
+    initialMessages?: readonly Message[];
+    initialNotices?: readonly {
+        text: string;
+        title: string;
+    }[];
+    initialSessionEvents?: readonly SessionEvent[];
+    initialSubagents?: readonly SubagentSummary[];
+    initialProjectSecretIds?: readonly string[];
+    initialSessionSecretIds?: readonly string[];
+    initialTasks?: readonly SessionTask[];
+    initialUsageEventId?: EventId;
+    initialWorkflowEventId?: EventId;
+    initialWorkflows?: readonly WorkflowRun[];
+    workflowsEnabled?: boolean;
+    initialUserInputs?: readonly UserInputRequest[];
+    listSecrets?: () => readonly SecretSummary[] | Promise<readonly SecretSummary[]>;
+    /** Where the user is, and how to switch it. Absent when the daemon does not report presence. */
+    presence?: {
+        get?: () => Promise<PresenceSnapshot>;
+        initial?: PresenceSnapshot;
+        set: (presenceId: string) => Promise<PresenceSnapshot>;
+    };
+    processManager: NativeProcessManager;
+    sessionBacked?: boolean;
+    tui: TUI;
+    idFactory?: () => string;
+    onDefaultModelChange?: (preference: DefaultModelPreference) => void | Promise<void>;
+    onTerminalFocusChange?: (focused: boolean) => void;
+    onUserActivity?: () => void;
+    onSettingsChange?: (settings: AppSettings) => void | Promise<void>;
+    onStopWorkflow?: (runId: string) => void | Promise<void>;
+    watchSubagentEvents?: (sessionId: string, signal: AbortSignal, onEvent: (event: SessionEvent) => void) => Promise<void>;
+    onExit?: () => void | Promise<void>;
+    respondUserInput?: (requestId: string, response: UserInputResponse) => void | Promise<void>;
+    now?: () => number;
+    readClipboardImage?: (options?: ReadClipboardImageOptions) => Promise<ClipboardImage | undefined>;
+    searchFiles?: (query: string) => Promise<readonly FileSearchResult[]>;
+    compactCompletedTurns?: boolean;
+    completionChime?: boolean;
+    registerSecret?: (registration: EnvironmentSecretRegistration) => SecretSummary | Promise<SecretSummary>;
+    unregisterSecret?: (id: string) => boolean | Promise<boolean>;
+    updateSecret?: (id: string, update: EnvironmentSecretUpdate) => SecretSummary | Promise<SecretSummary>;
+    detachSecret?: (id: string, scope: SecretAttachmentScope) => void | Promise<void>;
+    debugInfo?: AppDebugInfo;
+    showReasoning?: boolean;
+    showUsage?: boolean;
+    startupStatus?: StartupStatusCardModel;
+    version?: string;
+    theme?: TerminalTheme;
+}
+export interface AppDebugInfo {
+    daemonLogPath: string;
+    serverInspectorUrl?: string;
+    sessionId: string;
+    startInspectors: () => Promise<AppDebugInspectorUrls>;
+    stateDirectory: string;
+    tuiInspectorUrl?: string;
+    tuiStderrIsTTY: boolean;
+}
+interface AppDebugInspectorUrls {
+    serverInspectorUrl: string;
+    tuiInspectorUrl: string;
+}
+export interface DefaultModelPreference {
+    effort: string;
+    modelId: string;
+    providerId: string;
+    serviceTier: ServiceTier | null;
+}
+export interface AppSettings {
+    compactCompletedTurns: boolean;
+    completionChime: boolean;
+    showReasoning: boolean;
+    showUsage: boolean;
+}
+export declare class CodingAssistantApp implements Component, Focusable {
+    #private;
+    constructor(options: CodingAssistantAppOptions);
+    get focused(): boolean;
+    /** Adds a public API message delivered outside this app's active send call. */
+    applyMessage(message: Message): void;
+    /** Reconciles the TUI from an authoritative API snapshot after an event-stream gap. */
+    applyAgentSnapshot(snapshot: AgentSnapshot): void;
+    /** Applies a public API streaming or reset event delivered outside the active send call. */
+    applyAgentLoopEvent(event: AgentLoopEvent): void;
+    /** Opens a question received from the public agent event stream. */
+    applyUserInputRequest(request: UserInputRequest): void;
+    /** Clears a question after another client answered or canceled it. */
+    resolveUserInputRequest(requestId: string): void;
+    set focused(value: boolean);
+    start(options?: {
+        tuiAlreadyStarted?: boolean;
+    }): void;
+    stop(reason?: AppExitReason): Promise<void>;
+    waitForExit(): Promise<AppExitReason>;
+    applySessionEvent(event: SessionEvent): void;
+    waitForIdle(): Promise<void>;
+    handleInput(data: string): void;
+    invalidate(): void;
+    setTheme(theme: TerminalTheme): void;
+    /** Replace the footer's folded counters from the attributed subtree source of truth. */
+    applyUsageSummary(summary: GetSessionUsageResponse): void;
+    render(width: number): string[];
+    headerRenderCacheSizeForTesting(): number;
+}
+export {};

package/dist/app/CompletedTurn.d.ts

@@ -0,0 +1,11 @@
+export interface CompletedTurnStats {
+    additions: number;
+    deletions: number;
+    elapsedMs: number;
+    fileCount: number;
+    toolCount: number;
+}
+export interface CompletedTurn {
+    hiddenEntryIds: readonly string[];
+    stats: CompletedTurnStats;
+}

package/dist/app/FileMentionAutocomplete.d.ts

@@ -0,0 +1,30 @@
+import { type AutocompleteItem } from "@earendil-works/pi-tui";
+import type { FileSearchResult } from "../protocol/index.js";
+import { type FileMentionContext } from "./findFileMentionContext.js";
+export type SearchFilesForMention = (query: string) => Promise<readonly FileSearchResult[]>;
+export interface FileMentionAutocompleteSnapshot {
+    context: FileMentionContext;
+    items: readonly AutocompleteItem[];
+    selectedIndex: number;
+}
+export declare class FileMentionAutocomplete {
+    #private;
+    constructor(searchFiles: SearchFilesForMention, onChange: () => void);
+    clear(): void;
+    dismiss(lines: readonly string[], cursor: {
+        line: number;
+        col: number;
+    }): void;
+    handleInput(data: string, lines: readonly string[], cursor: {
+        line: number;
+        col: number;
+    }, onComplete: (path: string, context: FileMentionContext) => void): boolean;
+    snapshot(lines: readonly string[], cursor: {
+        line: number;
+        col: number;
+    }): FileMentionAutocompleteSnapshot | undefined;
+    sync(lines: readonly string[], cursor: {
+        line: number;
+        col: number;
+    }): void;
+}

package/dist/app/HappyTerminalProcessTerminal.d.ts

@@ -0,0 +1,7 @@
+import { ProcessTerminal } from "@earendil-works/pi-tui";
+export declare class HappyTerminalProcessTerminal extends ProcessTerminal {
+    #private;
+    start(onInput: (data: string) => void, onResize: () => void): void;
+    write(data: string): void;
+    stop(): void;
+}

package/dist/app/NoticeChild.d.ts

@@ -0,0 +1,4 @@
+export interface NoticeChild {
+    readonly label: string;
+    readonly reason: string;
+}

package/dist/app/SecretMenuController.d.ts

@@ -0,0 +1,31 @@
+import type { Component } from "@earendil-works/pi-tui";
+import type { SecretSummary } from "../protocol/index.js";
+import type { EnvironmentSecretRegistration, EnvironmentSecretUpdate, SecretAttachmentScope } from "../protocol/index.js";
+import type { AppTranscriptEntry } from "./AppTranscriptEntry.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+type TranscriptEntryInput = Omit<AppTranscriptEntry, "id"> & {
+    id?: string;
+};
+export interface SecretMenuControllerOptions {
+    appendEntry: (entry: TranscriptEntryInput) => void;
+    attachSecret: ((id: string, scope: SecretAttachmentScope) => void | Promise<void>) | undefined;
+    closePanel: () => void;
+    detachSecret: ((id: string, scope: SecretAttachmentScope) => void | Promise<void>) | undefined;
+    initialProjectSecretIds: readonly string[] | undefined;
+    initialSessionSecretIds: readonly string[] | undefined;
+    listSecrets: (() => readonly SecretSummary[] | Promise<readonly SecretSummary[]>) | undefined;
+    registerSecret: ((registration: EnvironmentSecretRegistration) => SecretSummary | Promise<SecretSummary>) | undefined;
+    requestRender: () => void;
+    showPanel: (component: Component) => void;
+    theme: TerminalTheme;
+    unregisterSecret: ((id: string) => boolean | Promise<boolean>) | undefined;
+    updateSecret: ((id: string, update: EnvironmentSecretUpdate) => SecretSummary | Promise<SecretSummary>) | undefined;
+}
+export declare class SecretMenuController {
+    #private;
+    constructor(options: SecretMenuControllerOptions);
+    hide(): void;
+    open(): void;
+    updateAttachments(projectSecretIds: readonly string[], sessionSecretIds: readonly string[]): void;
+}
+export {};

package/dist/app/SelectionList.d.ts

@@ -0,0 +1,24 @@
+import { type Component, type SelectItem } from "@earendil-works/pi-tui";
+export interface SelectionListTheme {
+    description: (text: string) => string;
+    scrollInfo: (text: string) => string;
+    selectedText: (text: string) => string;
+}
+/**
+ * Wraps pi-tui's `SelectList` so an option keeps the words that make it
+ * distinguishable. Selection state, keybindings, and navigation stay with
+ * pi-tui; only the row layout is replaced, because pi-tui renders one
+ * truncated line per option and a long question option needs several.
+ */
+export declare class SelectionList implements Component {
+    #private;
+    constructor(items: readonly SelectItem[], maxVisibleLines: number, theme: SelectionListTheme);
+    set onCancel(handler: () => void);
+    set onSelect(handler: (item: SelectItem) => void);
+    getSelectedItem(): SelectItem | undefined;
+    handleInput(data: string): void;
+    invalidate(): void;
+    setMaxVisibleLines(maxVisibleLines: number): void;
+    setSelectedIndex(index: number): void;
+    render(width: number): string[];
+}

package/dist/app/SessionDraftSync.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Mirrors the composer draft between this terminal and every other client
+ * attached to the same session.
+ *
+ * Keystrokes are coalesced so typing produces one write per pause rather than
+ * one per character, and the writer's own echo is recognised by origin so an
+ * update never bounces back into the editor the user is typing in.
+ *
+ * Each edit is stamped when the user types it, and the newest message wins.
+ * Ordering by typing time rather than by arrival means a draft that was already
+ * on its way cannot overwrite a message someone typed after it.
+ */
+export interface SessionDraftSyncOptions {
+    /** Identifies this client in the drafts it writes. */
+    origin: string;
+    /** Sends the draft to the daemon. Rejections are reported, never thrown. */
+    push: (draft: string, updatedAt: number) => Promise<void>;
+    /** Milliseconds of quiet typing before a draft is written. */
+    debounceMs?: number;
+    now?: () => number;
+    onError?: (error: unknown) => void;
+    setTimer?: (callback: () => void, delayMs: number) => NodeJS.Timeout;
+    clearTimer?: (timer: NodeJS.Timeout) => void;
+}
+export declare class SessionDraftSync {
+    #private;
+    constructor(options: SessionDraftSyncOptions & {
+        draft?: string;
+        draftUpdatedAt?: number;
+    });
+    /** The draft this client believes the daemon currently holds. */
+    get remote(): string;
+    /** Records the composer's current text and schedules a write if it changed. */
+    recordLocalText(text: string): void;
+    /**
+     * Applies a draft another client wrote. Returns the text the composer should
+     * show, or `undefined` when this client's own text should stand: either the
+     * update is our echo, or the user typed here more recently.
+     *
+     * A remote draft that is newer than an unsent local edit also discards that
+     * edit, so the losing text is not written back moments later.
+     */
+    applyRemoteDraft(draft: string, origin?: string, updatedAt?: number): string | undefined;
+    /** Writes any pending draft immediately and waits for it to land. */
+    flush(): Promise<void>;
+    /**
+     * Stops syncing. Later composer changes, including the teardown that clears
+     * the editor, no longer touch the stored draft.
+     */
+    dispose(): void;
+}

package/dist/app/StartupStatusApp.d.ts

@@ -0,0 +1,34 @@
+import { type Component, type Focusable, type TUI } from "@earendil-works/pi-tui";
+import type { AgentCatalogEntry } from "../client/index.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface StartupStatusAppOptions {
+    cwd: string;
+    now?: () => number;
+    rows?: () => number;
+    tui: TUI;
+    version: string;
+    theme?: TerminalTheme;
+}
+export declare class StartupStatusApp implements Component, Focusable {
+    #private;
+    focused: boolean;
+    constructor(options: StartupStatusAppOptions);
+    invalidate(): void;
+    render(width: number): string[];
+    /**
+     * Lets the user pick a saved agent on the same startup screen the daemon status uses, so
+     * `happy resume` never drops out of the TUI into a numbered prompt. Resolves undefined when the
+     * user dismisses the picker.
+     */
+    selectSession(options: {
+        agents: readonly AgentCatalogEntry[];
+        confirmVerb: string;
+        showDirectory: boolean;
+        subtitle: string;
+        title: string;
+    }): Promise<string | undefined>;
+    handleInput(data: string): void;
+    setStatus(status: string): void;
+    start(): void;
+    stop(): void;
+}

package/dist/app/StartupStatusCardModel.d.ts

@@ -0,0 +1,22 @@
+export interface StartupStatusCardUsageWindow {
+    capturedAt?: number;
+    percentLeft: number;
+    resetsIn?: string;
+}
+export interface StartupStatusCardUsage {
+    fiveHour?: StartupStatusCardUsageWindow;
+    weekly?: StartupStatusCardUsageWindow;
+}
+export interface StartupStatusCardModel {
+    access: string;
+    engineVersion?: string;
+    environment: string;
+    fast: boolean;
+    model: string;
+    provider: string;
+    reasoning: string;
+    session: "New session" | "Resumed";
+    usage?: StartupStatusCardUsage;
+    version: string;
+    workspace: string;
+}

package/dist/app/TemporaryFullscreenController.d.ts

@@ -0,0 +1,9 @@
+import { type TUI } from "@earendil-works/pi-tui";
+export declare class TemporaryFullscreenController {
+    #private;
+    constructor(tui: TUI);
+    open(restoreWithFullRedraw?: boolean): void;
+    render(lines: readonly string[], width: number, height: number): void;
+    close(): void;
+    dispose(): void;
+}

package/dist/app/TerminalColorLevel.d.ts

@@ -0,0 +1 @@
+export type TerminalColorLevel = "ansi256" | "truecolor";

package/dist/app/TerminalOutputTrace.d.ts

@@ -0,0 +1,12 @@
+interface TerminalDimensions {
+    columns: number;
+    rows: number;
+}
+export declare class TerminalOutputTrace {
+    #private;
+    constructor(path?: string | undefined);
+    recordInput(data: string, dimensions: TerminalDimensions): void;
+    recordOutput(data: string, dimensions: TerminalDimensions): void;
+    recordResize(stage: "signal" | "settled", dimensions: TerminalDimensions): void;
+}
+export {};

package/dist/app/TerminalTheme.d.ts

@@ -0,0 +1,11 @@
+export interface TerminalTheme {
+    accent: string;
+    brand: string;
+    error: string;
+    inputBackground: string;
+    isLight?: boolean;
+    primary: string;
+    secondary: string;
+    success: string;
+    warning: string;
+}

package/dist/app/TranscriptEntryRenderCache.d.ts

@@ -0,0 +1,10 @@
+import type { AppTranscriptEntry } from "./AppTranscriptEntry.js";
+export declare class TranscriptEntryRenderCache {
+    #private;
+    render(entry: AppTranscriptEntry, options: {
+        dynamicState: string;
+        theme: object;
+        width: number;
+    }, renderEntry: () => readonly string[]): readonly string[];
+    clear(): void;
+}

package/dist/app/applyWorkflowRunUpdate.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowRun, WorkflowRunUpdate } from "../protocol/index.js";
+export declare function applyWorkflowRunUpdate(workflows: readonly WorkflowRun[], update: WorkflowRunUpdate): readonly WorkflowRun[];

package/dist/app/blendComposerBackground.d.ts

@@ -0,0 +1,2 @@
+import type { RgbColor } from "@earendil-works/pi-tui";
+export declare function blendComposerBackground(background: RgbColor): RgbColor;

package/dist/app/boundedJsonStringify.d.ts

@@ -0,0 +1 @@
+export declare function boundedJsonStringify(value: unknown, maximumBytes: number): string;

package/dist/app/calculateCacheHitPercent.d.ts

@@ -0,0 +1,2 @@
+import type { Usage } from "../protocol/index.js";
+export declare function calculateCacheHitPercent(usage: Pick<Usage, "cacheRead" | "input">): number;

package/dist/app/codexDiffAnsi.d.ts

@@ -0,0 +1,17 @@
+export declare const CODEX_DIFF_ANSI: {
+    readonly reset: "\u001B[0m";
+    readonly foregroundReset: "\u001B[39m";
+    readonly bold: "\u001B[1m";
+    readonly notBoldOrDim: "\u001B[22m";
+    readonly dim: "\u001B[2m";
+    readonly green: "\u001B[32m";
+    readonly red: "\u001B[31m";
+    readonly primary: "\u001B[38;2;205;214;244m";
+    readonly keyword: "\u001B[38;2;203;166;247m";
+    readonly function: "\u001B[38;2;137;180;250m";
+    readonly punctuation: "\u001B[38;2;147;153;178m";
+    readonly argument: "\u001B[38;2;235;160;172m";
+    readonly string: "\u001B[38;2;166;227;161m";
+    readonly comment: "\u001B[38;2;108;112;134m";
+};
+export declare function codexDiffBackground(index: number): string;

package/dist/app/compactCompletedTurnEntries.d.ts

@@ -0,0 +1,2 @@
+import type { AppTranscriptEntry } from "./AppTranscriptEntry.js";
+export declare function compactCompletedTurnEntries(entries: readonly AppTranscriptEntry[]): AppTranscriptEntry[];

package/dist/app/containsMarkdownTable.d.ts

@@ -0,0 +1 @@
+export declare function containsMarkdownTable(text: string): boolean;

package/dist/app/createAgentMarkdownTheme.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownTheme } from "@earendil-works/pi-tui";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export declare function createAgentMarkdownTheme(theme: TerminalTheme): MarkdownTheme;

package/dist/app/createBackgroundTerminalViewer.d.ts

@@ -0,0 +1,16 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { BashSessionSnapshot } from "../protocol/index.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface BackgroundTerminalViewer extends Component {
+    setError(message: string | undefined): void;
+    update(snapshot: BashSessionSnapshot): void;
+}
+export declare function createBackgroundTerminalViewer(options: {
+    command: string;
+    cwd: string;
+    height: () => number;
+    onCancel: () => void;
+    onRequestRender: () => void;
+    onStop: () => Promise<BashSessionSnapshot | undefined>;
+    theme?: TerminalTheme;
+}): BackgroundTerminalViewer;

package/dist/app/createCompletedTurn.d.ts

@@ -0,0 +1,6 @@
+import type { AppTranscriptEntry } from "./AppTranscriptEntry.js";
+import type { CompletedTurn } from "./CompletedTurn.js";
+export declare function createCompletedTurn(entries: readonly AppTranscriptEntry[], elapsedMs: number): {
+    entry: AppTranscriptEntry;
+    turn: CompletedTurn;
+} | undefined;

package/dist/app/createEditorTheme.d.ts

@@ -0,0 +1,3 @@
+import type { EditorTheme } from "@earendil-works/pi-tui";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export declare function createEditorTheme(theme: TerminalTheme): EditorTheme;

package/dist/app/createFileMentionAutocompleteItems.d.ts

@@ -0,0 +1,3 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type { FileSearchResult } from "../protocol/index.js";
+export declare function createFileMentionAutocompleteItems(files: readonly FileSearchResult[]): AutocompleteItem[];

package/dist/app/createSecretInputPanel.d.ts

@@ -0,0 +1,12 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface CreateSecretInputPanelOptions {
+    label: string;
+    masked?: boolean;
+    onCancel: () => void;
+    onSubmit: (value: string) => void;
+    subtitle: string;
+    theme?: TerminalTheme;
+    title: string;
+}
+export declare function createSecretInputPanel(options: CreateSecretInputPanelOptions): Component;

package/dist/app/createSelectionPanel.d.ts

@@ -0,0 +1,14 @@
+import { type Component, type SelectItem } from "@earendil-works/pi-tui";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface CreateSelectionPanelOptions {
+    cancelDisabled?: boolean;
+    title: string;
+    subtitle: string;
+    items: readonly SelectItem[];
+    selectedValue?: string;
+    onSelect: (item: SelectItem) => void;
+    onCancel: () => void;
+    theme?: TerminalTheme;
+}
+export declare function createSelectionPanel(options: CreateSelectionPanelOptions): Component;
+export declare function fitSelectionPanelToViewport(component: Component, width: number, height: number): void;

package/dist/app/createSerialTaskQueue.d.ts

@@ -0,0 +1 @@
+export declare function createSerialTaskQueue(): <T>(task: () => Promise<T>) => Promise<T>;

package/dist/app/createSessionPicker.d.ts

@@ -0,0 +1,17 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { AgentCatalogEntry } from "../client/index.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface CreateSessionPickerOptions {
+    /** What Enter does to the highlighted session, such as "resume" or "fork". */
+    confirmVerb: string;
+    now?: () => number;
+    onCancel: () => void;
+    onSelect: (entry: AgentCatalogEntry) => void;
+    agents: readonly AgentCatalogEntry[];
+    showDirectory: boolean;
+    subtitle: string;
+    theme?: TerminalTheme;
+    title: string;
+}
+export declare function createSessionPicker(options: CreateSessionPickerOptions): Component;
+export declare function fitSessionPickerToViewport(component: Component, width: number, height: number): void;

package/dist/app/createSlashCommands.d.ts

@@ -0,0 +1,7 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+export interface SlashCommandItem extends AutocompleteItem {
+    aliases: readonly string[];
+}
+export declare function createSlashCommands(options?: {
+    workflowsEnabled?: boolean;
+}): SlashCommandItem[];

package/dist/app/createStopOnceHandler.d.ts

@@ -0,0 +1 @@
+export declare function createStopOnceHandler(stop: () => Promise<void> | void, onError: (error: unknown) => void): () => Promise<void>;

package/dist/app/createSubagentMonitor.d.ts

@@ -0,0 +1,17 @@
+import { type Component } from "@earendil-works/pi-tui";
+import type { SessionEvent, SubagentSummary } from "../protocol/index.js";
+import type { TerminalTheme } from "./TerminalTheme.js";
+export interface SubagentMonitor extends Component {
+    dispose(): void;
+}
+export interface CreateSubagentMonitorOptions {
+    getHeight(): number;
+    getSubagents(): readonly SubagentSummary[];
+    modelName(modelId: string): string;
+    now?: () => number;
+    onCancel(): void;
+    onRequestRender?(): void;
+    theme?: TerminalTheme;
+    watchSubagent(sessionId: string, signal: AbortSignal, onEvent: (event: SessionEvent) => void): Promise<void>;
+}
+export declare function createSubagentMonitor(options: CreateSubagentMonitorOptions): SubagentMonitor;