@sayknow-cli/coding-agent 0.4.2 → 0.4.3

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

@@ -0,0 +1,340 @@
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+import type { CompactionOutcome } from "@sayknow-cli/agent-core/compaction";
+import type { AssistantMessage, ImageContent, Message, UsageReport } from "@sayknow-cli/ai";
+import type { Component, Container, EditorTheme, Loader, SlashCommand, Spacer, Text, TUI } from "@sayknow-cli/tui";
+import type { KeybindingsManager } from "../config/keybindings";
+import type { Settings } from "../config/settings";
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
+import type { CompactOptions } from "../extensibility/extensions/types";
+import type { Skill } from "../extensibility/skills";
+import type { MCPManager } from "../runtime-mcp";
+import type { NotificationSessionReconcileResult, NotificationSessionStatus } from "../sdk/bus/session-control";
+import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+import type { HistoryStorage } from "../session/history-storage";
+import type { SessionContext, SessionManager } from "../session/session-manager";
+import type { CredentialAutoImportOptions } from "../setup/credential-auto-import";
+import type { LspStartupServerInfo } from "../tools";
+import type { AssistantMessageComponent } from "./components/assistant-message";
+import type { BashExecutionComponent } from "./components/bash-execution";
+import type { CommandPaletteAction } from "./components/command-palette";
+import type { CustomEditor } from "./components/custom-editor";
+import type { EvalExecutionComponent } from "./components/eval-execution";
+import type { HookEditorComponent } from "./components/hook-editor";
+import type { HookInputComponent } from "./components/hook-input";
+import type { HookSelectorComponent } from "./components/hook-selector";
+import type { PetMode } from "./components/sayknow-pet-widget";
+import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { StatusLineComponent } from "./components/tool-status-header";
+import type { IrcObservationLedger } from "./irc-observation-ledger";
+import type { OAuthManualInputManager } from "./oauth-manual-input";
+import type { Theme } from "./theme/theme";
+import type { ParsedIrcMessage } from "./utils/irc-message";
+export type TranscriptRebuildPolicy = "replace-identity" | "reconcile-same-transcript";
+export type CompactionQueuedMessage = {
+    text: string;
+    mode: "steer" | "followUp";
+    followUpQueuePolicy?: "sequential";
+};
+export type SubmittedUserInput = {
+    text: string;
+    images?: ImageContent[];
+    customType?: string;
+    display?: boolean;
+    cancelled: boolean;
+    started: boolean;
+};
+export type ComposerSubmissionOptions = Readonly<{
+    ownsComposer: boolean;
+    editor: CustomEditor;
+}>;
+export declare function canApplyComposerSubmission(options: ComposerSubmissionOptions | undefined, editor: CustomEditor): boolean;
+export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+export type TodoItem = {
+    content: string;
+    status: TodoStatus;
+    details?: string;
+    notes?: string[];
+};
+export type TodoPhase = {
+    name: string;
+    tasks: TodoItem[];
+};
+export type IrcArrivalSnapshot = Readonly<{
+    panelVisible: boolean;
+    /** User-requested open state; may be true while the panel yields at narrow widths. */
+    panelRequestedVisible: boolean;
+    sidebarAvailable: boolean;
+    resolvedToggleKey: string | null;
+}>;
+export interface InteractiveModeContext {
+    ui: TUI;
+    chatContainer: Container;
+    pendingMessagesContainer: Container;
+    statusContainer: Container;
+    todoContainer: Container;
+    btwContainer: Container;
+    editor: CustomEditor;
+    editorContainer: Container;
+    hookWidgetContainerAbove: Container;
+    hookWidgetContainerBelow: Container;
+    statusLine: StatusLineComponent;
+    session: AgentSession;
+    sessionManager: SessionManager;
+    settings: Settings;
+    keybindings: KeybindingsManager;
+    agent: AgentSession["agent"];
+    historyStorage?: HistoryStorage;
+    mcpManager?: MCPManager;
+    lspServers?: LspStartupServerInfo[];
+    /** Shared controller query; absent in ACP/lightweight test contexts. */
+    getCurrentSessionNotificationStatus?(): NotificationSessionStatus | undefined;
+    /** Toggle only the current session; absent in ACP/lightweight test contexts. */
+    setCurrentSessionNotificationsEnabled?(enabled: boolean): Promise<NotificationSessionReconcileResult | undefined>;
+    readonly ircLedger: IrcObservationLedger;
+    isInitialized: boolean;
+    isBackgrounded: boolean;
+    isBashMode: boolean;
+    isBashNoContext: boolean;
+    toolOutputExpanded: boolean;
+    todoExpanded: boolean;
+    hideThinkingBlock: boolean;
+    pendingImages: ImageContent[];
+    compactionQueuedMessages: CompactionQueuedMessage[];
+    pendingTools: Map<string, ToolExecutionHandle>;
+    pendingBashComponents: BashExecutionComponent[];
+    bashComponent: BashExecutionComponent | undefined;
+    pendingPythonComponents: EvalExecutionComponent[];
+    pythonComponent: EvalExecutionComponent | undefined;
+    isPythonMode: boolean;
+    streamingComponent: AssistantMessageComponent | undefined;
+    streamingMessage: AssistantMessage | undefined;
+    loadingAnimation: Loader | undefined;
+    autoCompactionLoader: Loader | undefined;
+    retryLoader: Loader | undefined;
+    autoCompactionEscapeHandler?: () => void;
+    retryEscapeHandler?: () => void;
+    retryEscapePrimed: boolean;
+    retryCountdownTimer?: NodeJS.Timeout;
+    unsubscribe?: () => void;
+    onInputCallback?: (input: SubmittedUserInput) => void;
+    optimisticUserMessageSignature: string | undefined;
+    locallySubmittedUserSignatures: Set<string>;
+    optimisticInjectedSignatures: Map<string, number>;
+    lastSigintTime: number;
+    lastEscapeTime: number;
+    lastComposerClearEscapeTime: number;
+    shutdownRequested: boolean;
+    hookSelector: HookSelectorComponent | undefined;
+    hookInput: HookInputComponent | undefined;
+    hookEditor: HookEditorComponent | undefined;
+    lastStatusSpacer: Spacer | undefined;
+    lastStatusText: Text | undefined;
+    fileSlashCommands: Set<string>;
+    skillCommands: Map<string, Skill>;
+    oauthManualInput: OAuthManualInputManager;
+    todoPhases: TodoPhase[];
+    init(): Promise<void>;
+    shutdown(): Promise<void>;
+    checkShutdownRequested(): Promise<void>;
+    setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    createBackgroundUiContext(): ExtensionUIContext;
+    setEditorComponent(factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined): void;
+    handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    showError(message: string): void;
+    showWarning(message: string): void;
+    notifyConfigChanged?: () => Promise<void> | void;
+    showNewVersionNotification(newVersion: string): void;
+    clearEditor(): void;
+    updatePendingMessagesDisplay(): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    flushPendingBashComponents(): void;
+    setWorkingMessage(message?: string): void;
+    applyPendingWorkingMessage(): void;
+    ensureLoadingAnimation(): void;
+    /**
+     * Commit a pet mode through the shared result-returning policy: capability
+     * is rechecked immediately before mutation and the preference persists only
+     * on acceptance. Returns whether the commit was accepted.
+     */
+    setPetMode(mode: PetMode): boolean;
+    /** Live-preview a pet skin during a selector without persisting. */
+    previewPetMode(mode: PetMode): void;
+    /**
+     * Commit a settings-overlay pet change without re-mounting the composer.
+     * Same shared commit policy and result semantics as `setPetMode`.
+     */
+    commitPetPreviewMode(mode: PetMode): boolean;
+    /** Re-mount the composer (pet-aware) after an overlay/selector closes. */
+    restoreComposer(): void;
+    startPendingSubmission(input: {
+        text: string;
+        images?: ImageContent[];
+        customType?: string;
+        display?: boolean;
+    }, options?: ComposerSubmissionOptions): SubmittedUserInput;
+    cancelPendingSubmission(): boolean;
+    markPendingSubmissionStarted(input: SubmittedUserInput): boolean;
+    finishPendingSubmission(input: SubmittedUserInput): void;
+    /**
+     * Marks a locally-initiated user submission so the eventual `message_start`
+     * event for that user message does not clobber the editor draft (see #783).
+     * Returns a dispose function that removes the signature; call it on
+     * delivery failure so a retry can be re-marked cleanly.
+     */
+    recordLocalSubmission(text: string, imageCount?: number): () => void;
+    /**
+     * Wraps `fn` in a `recordLocalSubmission` marker that is automatically
+     * removed if `fn` rejects. Use this for the common case where a thrown
+     * delivery error should leave the signature set untouched.
+     */
+    withLocalSubmission<T>(text: string, fn: () => Promise<T>, options?: {
+        imageCount?: number;
+    }): Promise<T>;
+    isKnownSlashCommand(text: string): boolean;
+    addMessageToChat(message: AgentMessage, options?: {
+        populateHistory?: boolean;
+    }): Component[];
+    addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[];
+    removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined;
+    resetRenderedIrcInlineComponents(): readonly (readonly Component[])[];
+    renderSessionContext(sessionContext: SessionContext, options?: {
+        updateFooter?: boolean;
+        populateHistory?: boolean;
+    }): void;
+    rebuildInitialMessages(policy: TranscriptRebuildPolicy, prebuiltContext?: SessionContext, options?: {
+        preserveExistingChat?: boolean;
+    }): void;
+    getUserMessageText(message: Message): string;
+    getAssistantViewportAnchorId?(message: AssistantMessage): string;
+    findLastAssistantMessage(): AssistantMessage | undefined;
+    extractAssistantText(message: AssistantMessage): string;
+    updateEditorTopBorder(): void;
+    updateEditorBorderColor(): void;
+    rebuildChatFromMessages(policy: TranscriptRebuildPolicy): void;
+    setTodos(todos: TodoItem[] | TodoPhase[]): void;
+    reloadTodos(): Promise<void>;
+    toggleTodoExpansion(): void;
+    toggleIrcSidebar(): void;
+    captureIrcArrivalSnapshot(): IrcArrivalSnapshot;
+    applyIrcSidebarAvailability(enabled: boolean): void;
+    resetIrcSidebarSession(): void;
+    handleExportCommand(text: string): Promise<void>;
+    handleShareCommand(): Promise<void>;
+    handleCopyCommand(sub?: string): void;
+    handleTodoCommand(args: string): Promise<void>;
+    handleSessionCommand(): Promise<void>;
+    handleJobsCommand(): Promise<void>;
+    handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
+    handleChangelogCommand(showFull?: boolean): Promise<void>;
+    handleHotkeysCommand(): void;
+    handleHelpCommand(): void;
+    handleToolsCommand(): void;
+    handleContextCommand(): void;
+    handleDumpCommand(): void;
+    handleDebugTranscriptCommand(): Promise<void>;
+    handleClearCommand(): Promise<boolean>;
+    handleContextClearCommand(): Promise<void>;
+    handleDropCommand(): Promise<boolean>;
+    handleForkCommand(): Promise<void>;
+    handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
+    handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
+    handleMCPCommand(text: string): Promise<void>;
+    handleSSHCommand(text: string): Promise<void>;
+    handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    handleHandoffCommand(customInstructions?: string): Promise<void>;
+    handleContributionPrepCommand(customInstructions?: string): Promise<void>;
+    handleMoveCommand(targetPath: string): Promise<void>;
+    handleRenameCommand(title: string): Promise<void>;
+    handleMemoryCommand(text: string): Promise<void>;
+    handleSTTToggle(): Promise<void>;
+    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
+    openInBrowser(urlOrPath: string): void;
+    /** Resolved source of truth for slash autocomplete and command palette entries. */
+    getSlashCommands?(): readonly SlashCommand[];
+    refreshSlashCommandState(cwd?: string): Promise<void>;
+    showCommandPalette(commands: SlashCommand[], actions: CommandPaletteAction[], executeSlashCommand: (name: string) => Promise<void>): void;
+    showSettingsSelector(): void;
+    showThemeSelector(): void;
+    showPetSelector(): void;
+    showHistorySearch(): void;
+    showExtensionsDashboard(): void;
+    showAgentsDashboard(): void;
+    showModelSelector(options?: {
+        temporaryOnly?: boolean;
+    }): void;
+    showEffortSelector(): void;
+    showProviderOnboarding(): void;
+    showPluginSelector(mode?: "install" | "uninstall"): void;
+    showUserMessageSelector(): void;
+    showTreeSelector(): void;
+    showSessionSelector(): void;
+    showSessionsDashboard(): void;
+    handleResumeSession(sessionPath: string): Promise<void>;
+    handleSessionDeleteCommand(): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string, options?: OAuthSelectorOptions): Promise<void>;
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showDebugSelector(): void;
+    showSessionObserver(): void;
+    showJobsOverlay(): void;
+    showTasksPane(): void;
+    showTranscriptViewer(): void;
+    isTranscriptViewerOpen(): boolean;
+    refreshTranscriptViewer(): void;
+    resetObserverRegistry(): void;
+    handleCtrlC(): void;
+    handleCtrlD(): void;
+    handleCtrlZ(): void;
+    handleDequeue(): void;
+    handleBackgroundCommand(): void;
+    handleImagePaste(): Promise<boolean>;
+    handleBtwCommand(question: string): Promise<void>;
+    hasActiveBtw(): boolean;
+    handleBtwEscape(): boolean;
+    cycleThinkingLevel(): void;
+    cycleRoleModel(options?: {
+        temporary?: boolean;
+    }): Promise<void>;
+    toggleToolOutputExpansion(): void;
+    setToolsExpanded(expanded: boolean): void;
+    toggleThinkingBlockVisibility(): void;
+    openExternalEditor(): void;
+    registerExtensionShortcuts(): void;
+    initHooksAndCustomTools(): Promise<void>;
+    emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
+    planModeController: Pick<import("./controllers/plan-mode-controller").PlanModeController, "enabled" | "paused" | "planFilePath" | "handleCommand" | "handleApproval" | "flushPendingModelSwitch">;
+    goalModeController: Pick<import("./controllers/goal-mode-controller").GoalModeController, "enabled" | "paused" | "handleCommand">;
+    setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    setHookStatus(key: string, text: string | undefined): void;
+    showHookSelector(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    hideHookSelector(): void;
+    showHookInput(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions, inputOptions?: {
+        readonly initialValue?: string;
+    }): Promise<string | undefined>;
+    hideHookInput(): void;
+    showHookEditor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    hideHookEditor(): void;
+    showHookNotify(message: string, type?: "info" | "warning" | "error"): void;
+    showHookCustom<T>(factory: (tui: TUI, theme: Theme, keybindings: KeybindingsManager, done: (result: T) => void) => (Component & {
+        dispose?(): void;
+    }) | Promise<Component & {
+        dispose?(): void;
+    }>, options?: {
+        overlay?: boolean;
+    }): Promise<T>;
+    showExtensionError(extensionPath: string, error: string): void;
+    showToolError(toolName: string, error: string): void;
+}
+export interface OAuthSelectorOptions {
+    allowExternalCredentialDiscovery?: boolean;
+    trigger?: "bare-login";
+    externalCredentialDiscover?: CredentialAutoImportOptions["discover"];
+}

package/dist/types/modes/utils/abort-message.d.ts

@@ -0,0 +1,4 @@
+export declare function buildAbortDisplayMessage({ errorMessage, retryAttempt, }: {
+    errorMessage?: string;
+    retryAttempt: number;
+}): string;

package/dist/types/modes/utils/context-usage.d.ts

@@ -0,0 +1,36 @@
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+import type { Model } from "@sayknow-cli/ai";
+import type { AgentSession } from "../../session/agent-session";
+import type { theme as Theme } from "../theme/theme";
+export { computeNonMessageTokens, estimateSkillsTokens, estimateToolSchemaTokens, } from "../../session/context-estimation";
+type CategoryId = "systemPrompt" | "systemContext" | "rules" | "tools" | "skills" | "messages" | "lastUserTurn";
+interface CategoryInfo {
+    id: CategoryId;
+    label: string;
+    tokens: number;
+    color: "accent" | "warning" | "success" | "userMessageText" | "customMessageLabel";
+    glyph: string;
+}
+export interface ContextBreakdown {
+    model: Model | undefined;
+    contextWindow: number;
+    categories: CategoryInfo[];
+    lastUserTurnTokens: number;
+    estimatedCategoryTotal: number;
+    usedTokens: number | null;
+    source: "provider_anchor" | "heuristic" | "unknown";
+    autoCompactBufferTokens: number;
+    freeTokens: number;
+}
+/**
+ * Compute a breakdown of estimated context usage by category for the active
+ * session and model.
+ */
+export declare function computeContextBreakdown(session: AgentSession, options?: {
+    messages?: readonly AgentMessage[];
+}): ContextBreakdown;
+/**
+ * Render a colorful context-usage panel as ANSI text. Output is a series of
+ * lines pairing the grid (left) with the legend (right).
+ */
+export declare function renderContextUsage(breakdown: ContextBreakdown, theme: typeof Theme): string;

package/dist/types/modes/utils/hotkeys-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { KeybindingsManager } from "../../config/keybindings";
+export interface HotkeysMarkdownBindings {
+    keybindings: Pick<KeybindingsManager, "getDisplayString">;
+}
+export declare function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string;

package/dist/types/modes/utils/injected-user-submission.d.ts

@@ -0,0 +1,52 @@
+import type { ImageContent, TextContent } from "@sayknow-cli/ai";
+import type { InteractiveModeContext } from "../types";
+/**
+ * Normalize the content passed to an extension `sendUserMessage` call into a
+ * plain text string plus its image attachments. Mirrors the normalization in
+ * `AgentSession.sendUserMessage` (text parts joined with "\n") so the resulting
+ * text matches the eventual user `message_start` payload.
+ */
+export declare function normalizeInjectedUserContent(content: string | (TextContent | ImageContent)[]): {
+    text: string;
+    images: ImageContent[];
+    imageCount: number;
+};
+/**
+ * Record a remotely/programmatically injected user message (e.g. Telegram
+ * inbound routed through the extension API) into the interactive TUI, so it is
+ * captured in prompt history and shown immediately instead of only appearing
+ * once the eventual `message_start` event lands.
+ *
+ * Local TUI submissions never reach this path (they go through
+ * `session.prompt(...)` / `startPendingSubmission`), so this cannot double-add
+ * local prompt history.
+ *
+ * - Always adds the injected text to editor prompt history.
+ * - Idle injections optimistically render the user message and record a pending
+ *   injected optimistic signature (a counting Map, so multiple idle injections
+ *   before the first `message_start` do not clobber each other); the later user
+ *   `message_start` consumes one count and skips both the duplicate chat add and
+ *   the defensive editor clear (so a locally typed draft is preserved).
+ * - Busy/queued injections refresh the pending-message display, which the
+ *   caller has already populated by invoking `session.sendUserMessage(...)`
+ *   before this helper.
+ *
+ * This helper never clears the editor text.
+ */
+export declare function applyInjectedUserSubmission(ctx: InteractiveModeContext, input: {
+    content: string | (TextContent | ImageContent)[];
+    queued: boolean;
+}): void;
+/**
+ * Record one pending optimistic render for an injected user message.
+ *
+ * Injected sends are fire-and-forget and multiple idle injections can be
+ * rendered before the first `message_start` arrives, so a counting Map (not a
+ * single slot) tracks how many optimistic renders are outstanding per signature.
+ */
+export declare function incrementInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): void;
+/**
+ * Consume one pending injected optimistic render for `signature`. Decrements the
+ * count (deleting the key at zero) and returns whether one was outstanding.
+ */
+export declare function consumeInjectedOptimisticSignature(ctx: InteractiveModeContext, signature: string): boolean;

package/dist/types/modes/utils/irc-message.d.ts

@@ -0,0 +1,38 @@
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+export type IrcMessageKind = "incoming" | "autoreply" | "relay";
+export type ParsedIrcMessage = {
+    observationId: string;
+    from: string;
+    to: string;
+    text: string;
+    timestamp: number;
+    kind: IrcMessageKind;
+};
+export interface IrcMessageBlock {
+    readonly sender: string;
+    readonly recipient: string;
+    readonly kind: "incoming" | "autoreply" | "outgoing";
+    readonly time: string;
+    readonly bodyLines: readonly string[];
+}
+export declare function projectIrcText(text: string, maxUtf8Bytes: number): {
+    text: string;
+    truncated: boolean;
+    utf8Bytes: number;
+};
+/** Normalizes and bounds untrusted IRC identity fields without splitting visible graphemes. */
+export declare function normalizeIrcIdentity(identity: string): string;
+/** Formats IRC observations into display-neutral semantic blocks for both IRC surfaces. */
+export declare function formatIrcMessageBlock(message: ParsedIrcMessage & {
+    timestamp: number;
+}): IrcMessageBlock;
+type IrcCustomMessage = Extract<AgentMessage, {
+    role: "custom";
+}>;
+export declare function isIrcCustomType(customType: string | undefined): customType is `irc:${IrcMessageKind}`;
+/**
+ * Normalizes every supported IRC custom message into its UI observation shape.
+ * Legacy records have no UUID, so their immutable payload is used as a stable key.
+ */
+export declare function parseIrcMessage(message: IrcCustomMessage): ParsedIrcMessage | undefined;
+export {};

package/dist/types/modes/utils/keybinding-matchers.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Match the coding-agent interrupt key.
+ *
+ * Interactive mode installs a keybinding manager that exposes `app.interrupt`
+ * globally, but some isolated component tests still run with only TUI
+ * keybindings registered. In that case, fall back to raw Escape matching.
+ */
+export declare function matchesAppInterrupt(data: string): boolean;
+export declare function matchesSelectCancel(data: string): boolean;
+export declare function matchesAppExternalEditor(data: string): boolean;

package/dist/types/modes/utils/terminal-bell.d.ts

@@ -0,0 +1,3 @@
+export type TerminalBellEvent = "complete" | "approval" | "ask";
+export declare function ringTerminalBell(event: TerminalBellEvent, output?: Pick<NodeJS.WriteStream, "write">): void;
+export declare function classifyHookSelectorBellEvent(title: string): TerminalBellEvent;

package/dist/types/modes/utils/tools-markdown.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "../../tools";
+export interface ToolsMarkdownBindings {
+    tools: ReadonlyArray<Pick<Tool, "description" | "name">>;
+}
+export declare function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string;

package/dist/types/modes/utils/ui-helpers.d.ts

@@ -0,0 +1,75 @@
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+import type { AssistantMessage, Message } from "@sayknow-cli/ai";
+import { type Component, type TUI } from "@sayknow-cli/tui";
+import { type ComposerSubmissionOptions, type InteractiveModeContext, type IrcArrivalSnapshot, type TranscriptRebuildPolicy } from "../../modes/types";
+import { type SessionContext } from "../../session/session-manager";
+import { type ParsedIrcMessage } from "./irc-message";
+export type { TranscriptRebuildPolicy } from "../../modes/types";
+export declare function prepareTranscriptRebuild(ui: TUI, policy: TranscriptRebuildPolicy): void;
+interface RenderInitialMessagesOptions {
+    preserveExistingChat?: boolean;
+}
+export declare function argsWithPartialJson(args: unknown, partialJson: unknown): unknown;
+export declare class CollapsedChatHistoryComponent implements Component {
+    readonly isCollapsedChatHistory = true;
+    count: number;
+    startTime: number;
+    endTime: number;
+    constructor(count: number, startTime: number, endTime: number);
+    merge(count: number, startTime: number, endTime: number): void;
+    render(_width: number): string[];
+    invalidate(): void;
+}
+export declare function addChatChild(ctx: InteractiveModeContext, component: Component): void;
+export declare function trimChatChildren(ctx: InteractiveModeContext): void;
+export declare class UiHelpers {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    assistantViewportAnchorId(message: AssistantMessage): string;
+    getRenderedIrcInlineComponents(): Map<string, readonly Component[]>;
+    removeRenderedIrcInlineComponents(observationId: string): readonly Component[] | undefined;
+    resetRenderedIrcInlineComponents(): readonly (readonly Component[])[];
+    addLiveIrcObservationToChat(message: ParsedIrcMessage, arrival: IrcArrivalSnapshot): Component[];
+    addRebuiltIrcObservationToChat(message: ParsedIrcMessage): Component[];
+    resetIrcSidebarHint(): void;
+    /** Extract text content from a user message */
+    getUserMessageText(message: Message): string;
+    /**
+     * Show a status message in the chat.
+     *
+     * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
+     * we update the previous status line instead of appending new ones to avoid log spam.
+     */
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    addMessageToChat(message: AgentMessage, options?: {
+        populateHistory?: boolean;
+    }): Component[];
+    /**
+     * Render session context to chat. Used for initial load and rebuild after compaction.
+     * @param sessionContext Session context to render
+     * @param options.updateFooter Update footer state
+     * @param options.populateHistory Add user messages to editor history
+     */
+    renderSessionContext(sessionContext: SessionContext, options?: {
+        updateFooter?: boolean;
+        populateHistory?: boolean;
+    }): void;
+    renderInitialMessages(prebuiltContext?: SessionContext, options?: RenderInitialMessagesOptions): void;
+    clearEditor(): void;
+    showError(errorMessage: string): void;
+    showWarning(warningMessage: string): void;
+    showNewVersionNotification(newVersion: string): void;
+    updatePendingMessagesDisplay(): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", options?: ComposerSubmissionOptions): void;
+    isKnownSlashCommand(text: string): boolean;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    /** Move pending bash components from pending area to chat */
+    flushPendingBashComponents(): void;
+    findLastAssistantMessage(): AssistantMessage | undefined;
+    extractAssistantText(message: AssistantMessage): string;
+}

package/dist/types/notifications/attachment-registry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Process-wide registry mapping a session id to a sink that delivers a local
+ * file to the session's connected Telegram chat as a document. Registered by
+ * the notifications extension; consumed by the telegram_send tool.
+ */
+/** Delivers a local file to the session's Telegram chat. */
+export type TelegramFileSink = (file: {
+    path: string;
+    caption?: string;
+}) => Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/** Register `sink` for `sessionId`. Returns a disposer that clears it. */
+export declare function registerTelegramFileSink(sessionId: string, sink: TelegramFileSink): () => void;
+/** The Telegram file sink for `sessionId`, if one is registered. */
+export declare function getTelegramFileSink(sessionId: string): TelegramFileSink | undefined;

package/dist/types/notifications/chat-adapters.d.ts

@@ -0,0 +1,9 @@
+import type { NotificationPresentationAdapter } from "./engine";
+type AdapterKind = "discord" | "slack";
+interface ChatAdapterOptions {
+    kind: AdapterKind;
+    channelId?: string;
+}
+export declare function createDiscordAdapter(opts?: Omit<ChatAdapterOptions, "kind">): NotificationPresentationAdapter;
+export declare function createSlackAdapter(opts?: Omit<ChatAdapterOptions, "kind">): NotificationPresentationAdapter;
+export {};