@sayknow-cli/coding-agent 0.4.2 → 0.4.4

package/dist/types/modes/components/hook-message.d.ts

@@ -0,0 +1,15 @@
+import { Container } from "@sayknow-cli/tui";
+import type { HookMessageRenderer } from "../../extensibility/hooks/types";
+import type { HookMessage } from "../../session/messages";
+/**
+ * Component that renders a custom message entry from hooks.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class HookMessageComponent extends Container {
+    #private;
+    private readonly message;
+    private readonly customRenderer?;
+    constructor(message: HookMessage<unknown>, customRenderer?: HookMessageRenderer | undefined);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Generic selector component for hooks.
+ * Displays a list of string options with keyboard navigation.
+ */
+import { type AutocompleteProvider, Container, type TUI } from "@sayknow-cli/tui";
+export interface HookSelectorOptions {
+    tui?: TUI;
+    timeout?: number;
+    onTimeout?: () => void;
+    initialIndex?: number;
+    outline?: boolean;
+    maxVisible?: number;
+    onLeft?: () => void;
+    onRight?: () => void;
+    onExternalEditor?: () => void;
+    helpText?: string;
+    /**
+     * When true, the focused option's label wraps across multiple rows so the
+     * full text is visible. Non-focused options remain single-row with the
+     * existing `…` truncation hint. When unset/false, rendering is
+     * byte-identical to the previous implementation for all consumers.
+     */
+    wrapFocused?: boolean;
+    scrollTitleRows?: number;
+    /**
+     * Inline free-text entry for the option with this label (e.g. the ask
+     * tool's "Other (type your own)"). Selecting it keeps the title and option
+     * list on screen and opens a prompt-style editor below the list instead of
+     * replacing the whole selector. Enter submits via `onSubmit`; Escape
+     * returns to option selection.
+     */
+    customInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+    };
+    clarificationInput?: {
+        optionLabel: string;
+        onSubmit: (text: string) => void;
+        allowEmpty?: boolean;
+    };
+    /**
+     * Autocomplete provider for the inline custom-input editor. When present,
+     * the "Other (type your own)" editor gains the same `@` file-link and `/`
+     * completion behavior as the main prompt editor.
+     */
+    autocompleteProvider?: AutocompleteProvider;
+    /**
+     * Maps raw single-key accelerators to option labels. Unset maps preserve
+     * the legacy selector key handling exactly.
+     */
+    acceleratorMap?: Readonly<Record<string, string>>;
+}
+export declare class HookSelectorComponent extends Container {
+    #private;
+    constructor(title: string, options: string[], onSelect: (option: string) => void, onCancel: () => void, opts?: HookSelectorOptions);
+    hasActiveInlineInput(): boolean;
+    handleInput(keyData: string): void;
+    dispose(): void;
+}

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

@@ -0,0 +1,36 @@
+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";
+export * from "./custom-message";
+export * from "./diff";
+export * from "./dynamic-border";
+export * from "./footer";
+export * from "./hook-editor";
+export * from "./hook-input";
+export * from "./hook-message";
+export * from "./hook-selector";
+export * from "./keybinding-hints";
+export * from "./login-dialog";
+export * from "./model-selector";
+export * from "./oauth-selector";
+export * from "./queue-mode-selector";
+export * from "./read-tool-group";
+export * from "./session-selector";
+export * from "./settings-selector";
+export * from "./show-images-selector";
+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";
+export * from "./user-message-selector";
+export * from "./visual-truncate";
+export * from "./welcome";

package/dist/types/modes/components/irc-sidebar.d.ts

@@ -0,0 +1,32 @@
+import { type Component, type ViewportAnchorProvider, type ViewportAnchorRender } from "@sayknow-cli/tui";
+import type { IrcObservationLedger } from "../irc-observation-ledger";
+export declare const IRC_SIDEBAR_WIDTH_RATIO = 0.3;
+export declare const IRC_SIDEBAR_MAX_RENDER_ROWS = 2048;
+/** Computes transcript/sidebar widths while preserving at least half the terminal for the transcript. */
+export declare function computeIrcSplitWidths(width: number): {
+    leftWidth: number;
+    separatorWidth: number;
+    rightWidth: number;
+};
+export interface IrcSidebarTheme {
+    fg(color: "dim" | "accent", text: string): string;
+    bold(text: string): string;
+    readonly boxSharp: {
+        readonly vertical: string;
+    };
+}
+export type IrcSidebarThemeSource = IrcSidebarTheme | (() => IrcSidebarTheme);
+/** Read-only IRC history alongside the active transcript. */
+export declare class IrcSplitViewComponent implements ViewportAnchorProvider {
+    #private;
+    private readonly leftPane;
+    private readonly ledger;
+    private readonly componentTheme;
+    constructor(leftPane: Component, ledger: IrcObservationLedger, componentTheme: IrcSidebarThemeSource);
+    get visible(): boolean;
+    effectiveSidebarVisible(width?: number): boolean;
+    setVisible(visible: boolean): void;
+    render(width: number): string[];
+    renderWithViewportAnchors(width: number): ViewportAnchorRender;
+    invalidate(): void;
+}

package/dist/types/modes/components/jobs-overlay-model.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure model helpers for the jobs overlay.
+ *
+ * Kept free of UI/Component dependencies so the grouping/ordering and
+ * detail-formatting logic is unit-testable. The selector controller wires these
+ * SelectItem lists into nested SelectLists (list -> detail -> confirm).
+ */
+import type { SelectItem } from "@sayknow-cli/tui";
+import type { JobsSnapshot } from "../jobs-observer";
+export type JobRefKind = "monitor" | "cron";
+export interface JobRef {
+    kind: JobRefKind;
+    id: string;
+}
+/** Compact relative time, e.g. "in 5m", "2m ago", "now". */
+export declare function formatRelative(targetMs: number | undefined, nowMs?: number): string;
+/** Parse a list item value back into a job reference. */
+export declare function parseJobRef(value: string): JobRef | null;
+/**
+ * Build the grouped jobs list: monitors first (newest-first), then crons
+ * (newest-first). The snapshot arrays are already sorted newest-first.
+ */
+export declare function buildJobsListItems(snapshot: JobsSnapshot): SelectItem[];
+/**
+ * Build the detail-level items for a job: read-only info rows (value "noop"),
+ * then the destructive action, then a back row. `output` is the bounded monitor
+ * output tail (ignored for cron jobs).
+ */
+export declare function buildJobDetailItems(snapshot: JobsSnapshot, ref: JobRef, output?: string): SelectItem[];
+/** Yes/No confirm items for a destructive action. */
+export declare function buildConfirmItems(actionLabel: string): SelectItem[];

package/dist/types/modes/components/jobs-overlay.d.ts

@@ -0,0 +1,30 @@
+import { Container, type SelectItem, SelectList } from "@sayknow-cli/tui";
+import type { JobsSnapshot } from "../jobs-observer";
+/**
+ * Generic single-level selector used by the jobs overlay. The selector
+ * controller mounts a fresh instance per navigation level (list -> detail ->
+ * confirm); focus is placed on the inner SelectList, matching the existing
+ * selector components (e.g. ThemeSelectorComponent).
+ */
+export declare class JobsSelectorComponent extends Container {
+    #private;
+    constructor(items: SelectItem[], onSelect: (item: SelectItem) => void, onCancel: () => void, maxVisible?: number);
+    getSelectList(): SelectList;
+}
+export interface JobsOverlayController {
+    acknowledgeFailures(): void;
+    getSnapshot(): JobsSnapshot;
+    getMonitorOutput(id: string): string;
+    cancelMonitor(id: string): boolean;
+    deleteCron(id: string): boolean;
+}
+export interface JobsOverlayCallbacks {
+    close(): void;
+    requestRender(): void;
+}
+export declare class JobsOverlayComponent extends Container {
+    #private;
+    constructor(controller: JobsOverlayController, callbacks: JobsOverlayCallbacks);
+    getFocus(): SelectList;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/keybinding-hints.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Utilities for formatting keybinding hints in the UI.
+ */
+import { type Keybinding } from "@sayknow-cli/tui";
+import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings";
+/**
+ * Get display string for an editor action.
+ */
+export declare function editorKey(action: Keybinding): string;
+/**
+ * Get display string for an app action.
+ */
+export declare function appKey(keybindings: KeybindingsManager, action: AppKeybinding): string;
+/**
+ * Format a keybinding hint with consistent styling: dim key, muted description.
+ * Looks up the key from editor keybindings automatically.
+ *
+ * @param action - Keybinding action name (e.g., "tui.select.confirm", "app.tools.expand")
+ * @param description - Description text (e.g., "to expand", "cancel")
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function keyHint(action: Keybinding, description: string): string;
+/**
+ * Format a keybinding hint for app-level actions.
+ * Requires the KeybindingsManager instance.
+ *
+ * @param keybindings - KeybindingsManager instance
+ * @param action - App keybinding name (e.g., "app.interrupt", "app.editor.external")
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function appKeyHint(keybindings: KeybindingsManager, action: AppKeybinding, description: string): string;
+/**
+ * Format a raw key string with description (for non-configurable keys like ↑↓).
+ *
+ * @param key - Raw key string
+ * @param description - Description text
+ * @returns Formatted string with dim key and muted description
+ */
+export declare function rawKeyHint(key: string, description: string): string;

package/dist/types/modes/components/login-dialog.d.ts

@@ -0,0 +1,32 @@
+import { Container, type TUI } from "@sayknow-cli/tui";
+/**
+ * Login dialog component - replaces editor during OAuth login flow
+ */
+export declare class LoginDialogComponent extends Container {
+    #private;
+    private onComplete;
+    constructor(tui: TUI, providerId: string, onComplete: (success: boolean, message?: string) => void);
+    get signal(): AbortSignal;
+    /**
+     * Called by onAuth callback - show URL and optional instructions
+     */
+    showAuth(url: string, instructions?: string): void;
+    /**
+     * Show input for manual code/URL entry (for callback server providers)
+     */
+    showManualInput(prompt: string): Promise<string>;
+    /**
+     * Called by onPrompt callback - show prompt and wait for input
+     * Note: Does NOT clear content, appends to existing (preserves URL from showAuth)
+     */
+    showPrompt(message: string, placeholder?: string): Promise<string>;
+    /**
+     * Show waiting message (for polling flows like GitHub Copilot)
+     */
+    showWaiting(message: string): void;
+    /**
+     * Called by onProgress callback
+     */
+    showProgress(message: string): void;
+    handleInput(data: string): void;
+}

package/dist/types/modes/components/message-frame.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared rendering for extension/hook custom message frames.
+ *
+ * Both `CustomMessageComponent` and `HookMessageComponent` wrap a
+ * `Spacer(1) + Box` layout, try a user-supplied renderer first, and fall
+ * back to a label + markdown body when the renderer returns nothing or
+ * throws. The only meaningful difference is that hook messages collapse to
+ * the first N lines when not expanded; extension messages render in full.
+ */
+import type { TextContent } from "@sayknow-cli/ai";
+import type { Box, Component } from "@sayknow-cli/tui";
+import { type Theme } from "../../modes/theme/theme";
+/** Message shape consumed by the shared frame. */
+export interface FramedMessage {
+    customType: string;
+    content: string | (TextContent | {
+        type: string;
+    })[];
+}
+/**
+ * Callable signature shared by `MessageRenderer` (extensions) and
+ * `HookMessageRenderer` (hooks). Both narrow `message` to their own type;
+ * this signature is the structural intersection callers can hand off here.
+ */
+export type FramedRenderer<M extends FramedMessage> = (message: M, options: {
+    expanded: boolean;
+}, theme: Theme) => Component | undefined;
+export interface RebuildFrameOptions<M extends FramedMessage> {
+    message: M;
+    box: Box;
+    expanded: boolean;
+    /** Collapse the markdown body to this many lines when `expanded` is false. Omit to never collapse. */
+    collapseAfterLines?: number;
+    customRenderer?: FramedRenderer<M>;
+}
+/**
+ * Attempt the custom renderer; on failure or undefined return, populate
+ * `box` with the default `[customType]` label + markdown body and return
+ * undefined. When the custom renderer succeeds, return its Component so the
+ * caller can mount it and skip the default box.
+ */
+export declare function renderFramedMessage<M extends FramedMessage>(opts: RebuildFrameOptions<M>): Component | undefined;

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

@@ -0,0 +1,61 @@
+import { ThinkingLevel } from "@sayknow-cli/agent-core";
+import { type Model } from "@sayknow-cli/ai";
+import { Container, Input, type TUI } from "@sayknow-cli/tui";
+import type { ModelRegistry, SkcModelAssignmentTargetId } from "../../config/model-registry";
+import { type ScopedModelSelection } from "../../config/model-resolver";
+import type { ModelProfileConfig } from "../../config/models-config-schema";
+import type { Settings } from "../../config/settings";
+type ScopedModelItem = ScopedModelSelection;
+export type ModelSelectorSelection = {
+    kind: "assignment";
+    model: Model;
+    role: SkcModelAssignmentTargetId | null;
+    roles?: readonly SkcModelAssignmentTargetId[];
+    thinkingLevel?: ThinkingLevel;
+    selector?: string;
+} | {
+    kind: "profile";
+    profileName: string;
+    setDefault: boolean;
+} | {
+    kind: "createProfile";
+    profile: ModelProfileConfig;
+} | {
+    kind: "login";
+    providerId: string;
+};
+type RoleSelectCallback = (selection: ModelSelectorSelection) => void | Promise<void>;
+/**
+ * Component that renders a canonical model selector with provider tabs.
+ * - Preset landing Left/Right: Collapse/expand selected provider
+ * - Model browser Tab/Arrow Left/Right: Switch between provider tabs
+ * - Arrow Up/Down: Navigate rows
+ * - Enter: Open assignment actions for default plus SKC role-agent models
+ * - Escape: Close selector
+ */
+export declare class ModelSelectorComponent extends Container {
+    #private;
+    constructor(tui: TUI, _currentModel: Model | undefined, settings: Settings, modelRegistry: ModelRegistry, scopedModels: ReadonlyArray<ScopedModelItem>, onSelect: RoleSelectCallback, onCancel: () => void, options?: {
+        temporaryOnly?: boolean;
+        initialSearchInput?: string;
+        sessionId?: string;
+        isFastForProvider?: (provider?: string) => boolean;
+        isFastForSubagentProvider?: (provider?: string) => boolean;
+        isCurrentModelFastModeActive?: () => boolean;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
+        configuredDefaultChain?: readonly string[];
+    });
+    refreshRoleAssignments(options?: {
+        currentModel?: Model;
+        currentThinkingLevel?: ThinkingLevel;
+        activeModelProfile?: string;
+    }): void;
+    handleInput(keyData: string): void;
+    getSearchInput(): Input;
+    __testSelectProfile(profileName: string, setDefault: boolean): Promise<void>;
+    __testSelectAssignment(selection: Omit<Extract<ModelSelectorSelection, {
+        kind: "assignment";
+    }>, "kind">): Promise<void>;
+}
+export {};

package/dist/types/modes/components/notifications-settings-editor.d.ts

@@ -0,0 +1,139 @@
+import { type Component, type Focusable, type SecretValue } from "@sayknow-cli/tui";
+import type { CasReceipt } from "../../config/atomic-yaml-patch";
+import type { BlockedTelegramRestoreResult, ProposedTelegramIdentity, TelegramDaemonReconnectOutcome } from "../../sdk/bus/notification-orchestration";
+import type { NotificationHealthReport, NotificationRecoveryReport, NotificationStatusReport, NotificationTestResult } from "../../sdk/bus/notification-service";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../../sdk/bus/session-control";
+/** Safe scalar notification preferences. Credentials and destination IDs are deliberately absent. */
+export interface NotificationsEditorPreferences {
+    redact: boolean;
+    verbosity: "lean" | "verbose";
+    sessionScope: "all" | "primary";
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+    toolActivityEnabled: boolean;
+    streamingEnabled: boolean;
+}
+/** Secret-safe snapshot used to render the Notifications tab. */
+export interface NotificationsEditorState {
+    status: NotificationStatusReport;
+    session: NotificationSessionStatus;
+    preferences: NotificationsEditorPreferences;
+    health?: NotificationHealthReport;
+}
+/**
+ * A one-way setup value accepted from the masked input. The operation adapter
+ * consumes the secret and returns a safe-to-render prepared draft.
+ */
+export interface NotificationsEditorSetupInput {
+    token: SecretValue;
+    /** Optional: omit to use daemon-aware private-chat discovery when polling is safe. */
+    chatId?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+    streamingEnabled: boolean;
+}
+/**
+ * Secret-safe setup draft. The adapter may retain its private credential while
+ * this object is live, but no raw token is exposed through this contract.
+ */
+export interface PreparedTelegramConfiguration {
+    chatId: string;
+    tokenMask: string;
+    tokenFingerprint?: string;
+    richEnabled: boolean;
+    richDraftEnabled: boolean;
+    streamingEnabled: boolean;
+}
+export interface NotificationsPreflightResult {
+    status: "ready" | "aborted" | "cancelled" | "error";
+    identity: ProposedTelegramIdentity;
+    message: string;
+    pairingSource?: "discovered" | "provided" | "reused";
+    draft?: PreparedTelegramConfiguration;
+}
+/** A successful configuration save always carries an opaque CAS receipt. */
+export type NotificationsConfigureCommitResult = {
+    status: "saved";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "blocked_identity";
+    receipt: CasReceipt;
+    message: string;
+    restore(): Promise<BlockedTelegramRestoreResult>;
+    retainCommitted(): void;
+};
+export interface NotificationsMutationResult {
+    message: string;
+    receipt?: CasReceipt;
+}
+export type NotificationsSaveInactiveResult = {
+    status: "saved_inactive";
+    receipt: CasReceipt;
+    message: string;
+} | {
+    status: "unavailable";
+    guidance: string;
+};
+/**
+ * Controller-injected boundary for the direct Notifications editor.
+ *
+ * The component only renders this contract and sends user intent through it:
+ * it never reads Settings, starts a daemon, or calls notification services.
+ */
+export interface NotificationsEditorOperations {
+    /** Combines a buildNotificationStatusReport-shaped status snapshot with the current session-control query. */
+    loadState(): Promise<NotificationsEditorState>;
+    /** Performs offline health refreshes and a non-cancellable reachability probe when requested. */
+    refreshHealth(input: {
+        probe: boolean;
+        signal?: AbortSignal;
+    }): Promise<NotificationHealthReport>;
+    sendTest(): Promise<NotificationTestResult>;
+    recover(): Promise<NotificationRecoveryReport>;
+    reconnect(): Promise<TelegramDaemonReconnectOutcome>;
+    /** Validates/discovers a Telegram destination and returns a secret-safe prepared draft. */
+    preflightProposedIdentity(input: NotificationsEditorSetupInput, signal: AbortSignal): Promise<NotificationsPreflightResult>;
+    /** Atomically persists a prepared Telegram configuration and returns its CAS-backed receipt. */
+    commitConfigure(draft: PreparedTelegramConfiguration): Promise<NotificationsConfigureCommitResult>;
+    /** Stores a prepared Telegram configuration inactive when the mixed-adapter rule permits it. */
+    saveInactive(draft: PreparedTelegramConfiguration): Promise<NotificationsSaveInactiveResult>;
+    /** Clears adapter-local ephemeral credential material for a prepared setup draft. Idempotent. */
+    discardConfigureDraft(draft: PreparedTelegramConfiguration): void;
+    /** Enables globally without requesting or exposing a credential. */
+    enableGlobally(): Promise<NotificationsMutationResult>;
+    disableGlobally(): Promise<NotificationsMutationResult>;
+    /** Removes only Telegram configuration; the adapter preserves Discord/Slack when configured. */
+    removeTelegram(): Promise<NotificationsMutationResult & {
+        globallyDisabled?: boolean;
+    }>;
+    setSessionLocal(enabled: boolean): Promise<NotificationSessionReconcileResult>;
+    /** Atomically persists the scalar preference draft. */
+    commitPreferences(preferences: NotificationsEditorPreferences): Promise<NotificationsMutationResult>;
+    /** Reconciles the current session after durable global configuration changes. */
+    reconcileCurrentSession(): Promise<NotificationSessionReconcileResult>;
+}
+export interface NotificationsSettingsEditorCallbacks {
+    onCancel?: () => void;
+}
+type EditorMode = "home" | "provider-selection" | "chat-entry" | "token-entry" | "pairing" | "review" | "preferences" | "confirmation";
+/**
+ * Direct tab content for notification setup and operations. It is deliberately
+ * independent of Settings and notification services; WI7b injects the adapter.
+ */
+export declare class NotificationsSettingsEditorComponent implements Component, Focusable {
+    #private;
+    private readonly operations;
+    private readonly callbacks;
+    focused: boolean;
+    constructor(operations: NotificationsEditorOperations, callbacks?: NotificationsSettingsEditorCallbacks);
+    /** True while a guarded operation or blocked restore/retain decision owns the editor. */
+    get navigationLocked(): boolean;
+    /** Current state is exposed for selector lifecycle coordination and focused tests. */
+    get mode(): EditorMode;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { Container } from "@sayknow-cli/tui";
+import type { AuthStorage } from "../../session/auth-storage";
+import type { ImportableCredential } from "../../setup/credential-import";
+/**
+ * Component that renders an OAuth provider selector.
+ */
+export declare class OAuthSelectorComponent extends Container {
+    #private;
+    constructor(mode: "login" | "logout", authStorage: AuthStorage, onSelect: (providerId: string) => void, onCancel: () => void, options?: {
+        validateAuth?: (providerId: string) => Promise<boolean>;
+        requestRender?: () => void;
+        externalCredentialCandidates?: ImportableCredential[];
+    });
+    stopValidation(): void;
+    dispose(): void;
+    handleInput(keyData: string): void;
+}

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

@@ -0,0 +1,37 @@
+import { type SelectItem } from "@sayknow-cli/tui";
+export type PetPixelProtocol = "sixel" | "kitty";
+export declare const PET_UNAVAILABLE_DESCRIPTION = "Unavailable: requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_SAVED_UNAVAILABLE_DESCRIPTION = "Saved, unavailable \u2014 requires compatible Kitty or Sixel overlay rendering";
+export declare const PET_UNAVAILABLE_WARNING = "\u26A0 Pets aren\u2019t available in this terminal. Its image support isn\u2019t compatible with Sayknow Pet\u2019s overlay rendering yet. Try Kitty, Ghostty, WezTerm, or a terminal with compatible Sixel support.";
+export declare function getPetUnavailableWarning(env?: NodeJS.ProcessEnv): string;
+export declare function getPetPixelProtocol(): PetPixelProtocol | null;
+export declare function isPetAvailable(): boolean;
+export declare function createPetSelectItems(options: ReadonlyArray<SelectItem>, currentValue: string, available: boolean): SelectItem[];
+/**
+ * Grace period before declaring the terminal pet-incapable at startup. The
+ * asynchronous Sixel capability probe starts inside `TUI.start()` and answers
+ * within its own 250 ms deadline; this margin covers probe scheduling so a
+ * supported terminal is never told it is incompatible while the probe is
+ * still in flight.
+ */
+export declare const PET_CAPABILITY_SETTLE_MS = 1000;
+/**
+ * Whether the asynchronous startup Sixel capability probe may still enable
+ * graphics for this session, meaning current unavailability is not final.
+ */
+export declare function isPetCapabilityProbePending(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/**
+ * Deliver the pet-unavailable startup warning only once the capability
+ * question is settled. With no probe pending, unavailability is final and
+ * `onUnavailable` fires immediately. While a probe may still enable
+ * graphics, the warning is deferred: a protocol-change event cancels it (the
+ * saved pet re-applies through the existing subscription), and only the
+ * settle deadline passing with the terminal still unavailable emits it.
+ * Returns a disposer that cancels the pending decision.
+ */
+export declare function warnWhenPetCapabilitySettled(options: {
+    probePending: boolean;
+    isAvailable?: () => boolean;
+    onUnavailable: () => void;
+    settleMs?: number;
+}): () => void;

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

@@ -0,0 +1,11 @@
+import { Container, type SelectList } from "@sayknow-cli/tui";
+import type { PetMode } from "./sayknow-pet-widget";
+/**
+ * Theme-style picker for the sayknow pet skin (Off / RedSayknow / BlueSayknow). Preview
+ * fires as the selection moves; select commits, cancel restores.
+ */
+export declare class PetSelectorComponent extends Container {
+    #private;
+    constructor(current: PetMode, onSelect: (mode: PetMode) => void, onCancel: () => void, onPreview: (mode: PetMode) => void, available: boolean);
+    getSelectList(): SelectList;
+}

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

@@ -0,0 +1,43 @@
+import { Container, type KeyId, type MouseEvent } from "@sayknow-cli/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/plugin-selector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Interactive marketplace plugin selector.
+ *
+ * Shows available plugins from all configured marketplaces in a SelectList.
+ * Selecting a plugin triggers installation. Esc cancels.
+ */
+import { Container, SelectList } from "@sayknow-cli/tui";
+export interface PluginSelectorCallbacks {
+    onSelect: (pluginName: string, marketplace: string, scope?: "user" | "project") => void;
+    onCancel: () => void;
+}
+export interface PluginItem {
+    plugin: {
+        name: string;
+        version?: string;
+        description?: string;
+    };
+    marketplace: string;
+    /** Scope of this entry. When set, appended to the label and forwarded to onSelect. */
+    scope?: "user" | "project";
+}
+export declare class PluginSelectorComponent extends Container {
+    #private;
+    constructor(marketplaceCount: number, plugins: PluginItem[], installedIds: Set<string>, callbacks: PluginSelectorCallbacks);
+    getSelectList(): SelectList;
+}