@sayknow-cli/coding-agent 0.4.1 → 0.4.3

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

@@ -0,0 +1,10 @@
+import { Container, type SelectList } from "@sayknow-cli/tui";
+/**
+ * Component that renders a theme selector.
+ * Themes must be pre-loaded and passed to the constructor.
+ */
+export declare class ThemeSelectorComponent extends Container {
+    #private;
+    constructor(currentTheme: string, themes: string[], onSelect: (themeName: string) => void, onCancel: () => void, onPreview: (themeName: string) => void);
+    getSelectList(): SelectList;
+}

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

@@ -0,0 +1,15 @@
+import { type ThinkingLevel as ThinkingLevelValue } from "@sayknow-cli/agent-core";
+import { Container, SelectList } from "@sayknow-cli/tui";
+export interface ThinkingSelectorSelection {
+    level: ThinkingLevelValue;
+    persistDefault: boolean;
+}
+/**
+ * Component that renders a thinking level selector with borders
+ */
+export declare class ThinkingSelectorComponent extends Container {
+    #private;
+    constructor(currentLevel: ThinkingLevelValue | undefined, availableLevels: ThinkingLevelValue[], onSelect: (selection: ThinkingSelectorSelection) => void, onCancel: () => void);
+    handleInput(data: string): void;
+    getSelectList(): SelectList;
+}

package/dist/types/modes/components/todo-reminder.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "@sayknow-cli/tui";
+import type { TodoItem } from "../../tools/todo-write";
+/**
+ * Component that renders a todo completion reminder notification.
+ * Shows when the agent stops with incomplete todos.
+ */
+export declare class TodoReminderComponent extends Container {
+    #private;
+    private readonly todos;
+    private readonly attempt;
+    private readonly maxAttempts;
+    constructor(todos: TodoItem[], attempt: number, maxAttempts: number);
+}

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

@@ -0,0 +1,70 @@
+import type { AgentTool } from "@sayknow-cli/agent-core";
+import { Container, type TUI } from "@sayknow-cli/tui";
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    editFuzzyThreshold?: number;
+    editAllowFuzzy?: boolean;
+    hashlineAutoDropPureInsertDuplicates?: boolean;
+}
+export interface ToolExecutionHandle {
+    updateArgs(args: any, toolCallId?: string): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        }>;
+        details?: any;
+        isError?: boolean;
+    }, isPartial?: boolean, toolCallId?: string): void;
+    setArgsComplete(toolCallId?: string): void;
+    setExpanded(expanded: boolean): void;
+    /**
+     * Applies an explicit fold choice for this renderer instance. The pin lasts
+     * only for this instance; transcript rebuilds recreate it from global state.
+     * Optional for source compatibility: this interface is publicly exported and
+     * pre-existing structural implementers must keep compiling. Dispatchers must
+     * guard with `typeof handle.setManuallyExpanded === "function"` and fall
+     * back to {@link setExpanded}.
+     */
+    setManuallyExpanded?(expanded: boolean): void;
+}
+/**
+ * Component that renders a tool call with its result (updateable)
+ */
+export declare class ToolExecutionComponent extends Container {
+    #private;
+    constructor(toolName: string, args: any, options: ToolExecutionOptions | undefined, tool: AgentTool | undefined, ui: TUI, cwd?: string, _toolCallId?: string);
+    updateArgs(args: any, _toolCallId?: string): void;
+    /**
+     * Signal that args are complete (tool is about to execute).
+     * This triggers an immediate final diff computation for edit-like tools.
+     */
+    setArgsComplete(_toolCallId?: string): void;
+    updateResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+            data?: string;
+            mimeType?: string;
+        }>;
+        details?: any;
+        isError?: boolean;
+    }, isPartial?: boolean, _toolCallId?: string): void;
+    /**
+     * Stop spinner animation and cleanup resources.
+     */
+    stopAnimation(): void;
+    dispose(): void;
+    /** Applies automatic expansion unless this renderer instance has an explicit fold choice. */
+    setExpanded(expanded: boolean): void;
+    /**
+     * Applies and pins an explicit fold choice for this renderer instance only.
+     * Transcript rebuilds recreate components from global state and drop this pin.
+     */
+    setManuallyExpanded(expanded: boolean): void;
+    setShowImages(show: boolean): void;
+    invalidate(): void;
+    render(width: number): string[];
+}

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

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

package/dist/types/modes/components/tool-transcript-format.d.ts

@@ -0,0 +1,77 @@
+import type { Theme } from "../theme/theme";
+export declare const MAX_TOOL_ARGS_CHARS = 500;
+export declare const TOOL_RESULT_MAX_EXPANDED_LINES = 100;
+export declare const INPUT_MAX_SOURCE_BYTES = 1048576;
+export declare const INPUT_MAX_SOURCE_LINES = 50000;
+export declare const INPUT_MAX_SCALAR_LEN = 8192;
+export declare const INPUT_MAX_JSON_DEPTH = 32;
+export declare const INPUT_MAX_JSON_NODES = 20000;
+export type ToolDisplaySections = {
+    callLines: string[];
+    statusLines: string[];
+    resultText: string;
+};
+/**
+ * Produces final, terminal-safe rich display lines for an expanded tool entry.
+ * It owns validation, width-aware wrapping, and the result-only visible cap.
+ */
+export declare function renderToolDisplayLines(descriptor: ToolTranscriptRenderDescriptor, contentWidth: number, theme: Theme): string[];
+export type ToolTranscriptRenderDescriptor = Readonly<{
+    name: string;
+    args: Record<string, unknown>;
+    intent?: string;
+    resultContent: string;
+    details?: string;
+    detailsData?: unknown;
+    isError: boolean;
+    isPartial: boolean;
+    hasResult: boolean;
+    inputTruncated: boolean;
+}>;
+export type BuildToolTranscriptEntryInput = {
+    canonicalPayload: import("../transcript-item-registry").TranscriptSourcePayload;
+    renderDescriptor: ToolTranscriptRenderDescriptor;
+    capabilities: import("../transcript-item-registry").TranscriptItemCapabilities;
+    identity: {
+        id: string;
+        label: string;
+        display?: "full";
+    };
+};
+/**
+ * Shared tool projection for the main transcript and session observer.
+ * `payload` is canonical/copyable source; display is derived only from the
+ * sanitized, frozen descriptor. The observer's whole-entry 100-line cap and
+ * the main view's tool-only result cap intentionally remain surface-specific.
+ */
+export declare function buildToolTranscriptEntry(input: BuildToolTranscriptEntryInput): import("./transcript-viewer-overlay").TranscriptViewerEntry;
+/** Sanitizes and freezes all display-only values before tool formatting. */
+export declare function createToolTranscriptRenderDescriptor(input: {
+    name: unknown;
+    args: unknown;
+    intent?: unknown;
+    resultContent: unknown;
+    details?: unknown;
+    detailsData?: unknown;
+    isError?: unknown;
+    isPartial?: unknown;
+    hasResult?: unknown;
+    inputTruncated?: unknown;
+}): ToolTranscriptRenderDescriptor;
+type ToolCallFields = {
+    name: string;
+    args: Record<string, unknown>;
+    intent?: string;
+};
+type ToolResultFields = {
+    resultText: string;
+    isError: boolean;
+    hasResult: boolean;
+};
+export type ToolTranscriptFields = ToolCallFields & ToolResultFields;
+export declare function formatToolArgs(name: string, args: Record<string, unknown>): string;
+export declare function composeToolCall({ name, args, intent }: ToolCallFields): string;
+export declare function composeToolResult({ resultText, isError, hasResult }: ToolResultFields): string;
+export declare function composeToolText(fields: ToolTranscriptFields): string;
+export declare function toolDisplayText(fields: ToolTranscriptFields, expanded: boolean): string;
+export {};

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

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

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

@@ -0,0 +1,31 @@
+import { type Component, Container } from "@sayknow-cli/tui";
+import type { TreeFilterMode } from "../../config/settings-schema";
+import type { SessionTreeNode } from "../../session/session-manager";
+/** Filter mode for tree display */
+type FilterMode = TreeFilterMode;
+declare class TreeList implements Component {
+    #private;
+    private readonly currentLeafId;
+    private readonly maxVisibleLines;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, maxVisibleLines: number, initialFilterMode?: FilterMode, initialSelectedId?: string);
+    invalidate(): void;
+    getSearchQuery(): string;
+    getSelectedNode(): SessionTreeNode | undefined;
+    updateNodeLabel(entryId: string, label: string | undefined): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a session tree selector for navigation
+ */
+export declare class TreeSelectorComponent extends Container {
+    #private;
+    private readonly onLabelChangeCallback?;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string) => void, onCancel: () => void, onLabelChangeCallback?: ((entryId: string, label: string | undefined) => void) | undefined, initialFilterMode?: FilterMode);
+    handleInput(keyData: string): void;
+    getTreeList(): TreeList;
+}
+export {};

package/dist/types/modes/components/ttsr-notification.d.ts

@@ -0,0 +1,13 @@
+import { Container } from "@sayknow-cli/tui";
+import type { Rule } from "../../capability/rule";
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ */
+export declare class TtsrNotificationComponent extends Container {
+    #private;
+    private readonly rules;
+    constructor(rules: Rule[]);
+    setExpanded(expanded: boolean): void;
+    isExpanded(): boolean;
+}

package/dist/types/modes/components/two-column-body.d.ts

@@ -0,0 +1,9 @@
+import { type Component } from "@sayknow-cli/tui";
+export declare class TwoColumnBody implements Component {
+    private readonly leftPane;
+    private readonly rightPane;
+    private readonly maxHeight;
+    constructor(leftPane: Component, rightPane: Component, maxHeight: number);
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/types/modes/components/user-message-selector.d.ts

@@ -0,0 +1,28 @@
+import { type Component, Container } from "@sayknow-cli/tui";
+interface UserMessageItem {
+    id: string;
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Custom user message list component with selection
+ */
+declare class UserMessageList implements Component {
+    #private;
+    private readonly messages;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    constructor(messages: UserMessageItem[]);
+    invalidate(): void;
+    render(width: number): string[];
+    handleInput(keyData: string): void;
+}
+/**
+ * Component that renders a user message selector for branching
+ */
+export declare class UserMessageSelectorComponent extends Container {
+    #private;
+    constructor(messages: UserMessageItem[], onSelect: (entryId: string) => void, onCancel: () => void);
+    getMessageList(): UserMessageList;
+}
+export {};

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

@@ -0,0 +1,8 @@
+import { Container } from "@sayknow-cli/tui";
+/**
+ * Component that renders a user message
+ */
+export declare class UserMessageComponent extends Container {
+    #private;
+    constructor(text: string, synthetic?: boolean, viewportAnchorId?: string);
+}

package/dist/types/modes/components/visual-truncate.d.ts

@@ -0,0 +1,19 @@
+export interface VisualTruncateResult {
+    /** The visual lines to display */
+    visualLines: string[];
+    /** Number of visual lines that were skipped (hidden) */
+    skippedCount: number;
+}
+/**
+ * Truncate text to a maximum number of visual lines (from the end).
+ * This accounts for line wrapping based on terminal width.
+ *
+ * @param text - The text content (may contain newlines)
+ * @param maxVisualLines - Maximum number of visual lines to show
+ * @param width - Terminal/render width
+ * @param paddingX - Horizontal padding for Text component (default 0).
+ *                   Use 0 when result will be placed in a Box (Box adds its own padding).
+ *                   Use 1 when result will be placed in a plain Container.
+ * @returns The truncated visual lines and count of skipped lines
+ */
+export declare function truncateToVisualLines(text: string, maxVisualLines: number, width: number, paddingX?: number): VisualTruncateResult;

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

@@ -0,0 +1,46 @@
+import { type Component } from "@sayknow-cli/tui";
+export interface RecentSession {
+    name: string;
+    timeAgo: string;
+}
+export interface LspServerInfo {
+    name: string;
+    status: "idle" | "ready" | "error" | "connecting";
+    fileTypes: string[];
+}
+export type WelcomeLogoMode = "unicode" | "square" | "ascii";
+export interface WelcomeComponentOptions {
+    getViewportRows?: () => number | undefined;
+    getReservedBottomRows?: (termWidth: number) => number;
+    changelogMarkdown?: string;
+    collapseChangelog?: boolean;
+    buildLabel?: string;
+}
+/**
+ * Sayknow-CLI launch surface: a blue-gradient SAYKNOW wordmark, compact
+ * command affordances, and project signals — a distinct identity, not a
+ * copy of another agent shell.
+ */
+export declare class WelcomeComponent implements Component {
+    #private;
+    private readonly version;
+    private modelName;
+    private providerName;
+    private recentSessions;
+    private lspServers;
+    private readonly logoMode;
+    private readonly options;
+    constructor(version: string, modelName: string, providerName: string, recentSessions?: RecentSession[], lspServers?: LspServerInfo[], logoMode?: WelcomeLogoMode, options?: WelcomeComponentOptions);
+    invalidate(): void;
+    /**
+     * Play a one-shot intro that sweeps the gradient through every phase
+     * before settling on the resting frame. Safe to call multiple times —
+     * subsequent calls reset and replay.
+     */
+    playIntro(requestRender: () => void): void;
+    dispose(): void;
+    setModel(modelName: string, providerName: string): void;
+    setRecentSessions(sessions: RecentSession[]): void;
+    setLspServers(servers: LspServerInfo[]): void;
+    render(termWidth: number): string[];
+}

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

@@ -0,0 +1,10 @@
+import type { InteractiveModeContext } from "../types";
+export declare class BtwController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    hasActiveRequest(): boolean;
+    handleEscape(): boolean;
+    dispose(): void;
+    start(question: string): Promise<void>;
+}

package/dist/types/modes/controllers/command-controller-shared.d.ts

@@ -0,0 +1,47 @@
+import type { SourceMeta } from "../../capability/types";
+import type { InteractiveModeContext } from "../types";
+export type ScopeValue = "project" | "user";
+export type ScopeFlagResult = {
+    ok: true;
+    scope: ScopeValue;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Validate the value following a `--scope` flag.
+ */
+export declare function readScopeFlag(value: string | undefined): ScopeFlagResult;
+export type RemoveArgs = {
+    name: string | undefined;
+    scope: ScopeValue;
+};
+export type ParseRemoveResult = {
+    ok: true;
+    value: RemoveArgs;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Parse the argument tail of `/<cmd> remove <name> [--scope project|user]`.
+ *
+ * `rest` is the text after the subcommand keyword. The caller is responsible
+ * for emitting the command-specific "<entity> name required" usage hint when
+ * `value.name` is undefined.
+ */
+export declare function parseRemoveArgs(rest: string): ParseRemoveResult;
+/**
+ * Group capability-loaded items by their source provider+path, yielding each
+ * group with a display-ready `shortPath`.
+ */
+export declare function groupBySource<T>(items: Iterable<T>, getSource: (item: T) => SourceMeta): Iterable<{
+    providerName: string;
+    shortPath: string;
+    items: T[];
+}>;
+/**
+ * Render a message block (DynamicBorder / Text / DynamicBorder) into the chat
+ * container and request a render.
+ */
+export declare function showCommandMessage(ctx: InteractiveModeContext, text: string): void;

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

@@ -0,0 +1,40 @@
+import { type CompactionOutcome } from "@sayknow-cli/agent-core/compaction";
+import { type ProviderDetails, type UsageReport } from "@sayknow-cli/ai";
+import type { CompactOptions } from "../../extensibility/extensions/types";
+import { theme } from "../../modes/theme/theme";
+import type { InteractiveModeContext } from "../../modes/types";
+export declare class CommandController {
+    #private;
+    private readonly ctx;
+    constructor(ctx: InteractiveModeContext);
+    openInBrowser(urlOrPath: string): void;
+    handleExportCommand(text: string): Promise<void>;
+    handleDumpCommand(): void;
+    handleDebugTranscriptCommand(): Promise<void>;
+    handleShareCommand(): Promise<void>;
+    handleCopyCommand(sub?: string): 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;
+    handleMemoryCommand(text: string): Promise<void>;
+    handleClearCommand(): Promise<boolean>;
+    handleContextClearCommand(): Promise<void>;
+    handleDropCommand(): Promise<boolean>;
+    handleForkCommand(): Promise<void>;
+    handleMoveCommand(targetPath: string): Promise<void>;
+    handleRenameCommand(title: string): Promise<void>;
+    handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
+    handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
+    handleCompactCommand(customInstructions?: string): Promise<CompactionOutcome>;
+    handleSkillCommand(skillPath: string, args: string): Promise<void>;
+    executeCompaction(customInstructionsOrOptions?: string | CompactOptions, isAuto?: boolean): Promise<CompactionOutcome>;
+    handleHandoffCommand(customInstructions?: string): Promise<void>;
+    handleContributionPrepCommand(customInstructions?: string): Promise<void>;
+}
+export declare function renderProviderSection(details: ProviderDetails, uiTheme: Pick<typeof theme, "fg">): string;
+export declare function renderUsageReports(reports: UsageReport[], uiTheme: typeof theme, nowMs: number, availableWidth: number): string;

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

@@ -0,0 +1,21 @@
+import { type Component } from "@sayknow-cli/tui";
+import type { InteractiveModeContext } from "../../modes/types";
+import type { AgentSessionEvent } from "../../session/agent-session";
+/** Test-only performance counters for advisory baseline tests. */
+export declare const __eventControllerPerfCounters: {
+    messageUpdateContentVisits: number;
+    reset(): void;
+};
+export declare class EventController {
+    #private;
+    private ctx;
+    constructor(ctx: InteractiveModeContext);
+    dispose(): void;
+    subscribeToAgent(): void;
+    handleEvent(event: AgentSessionEvent): Promise<void>;
+    clearIrcExpiryTimers(): void;
+    resetIrcObservations(): void;
+    reconcileIrcExpiryTimers(componentsByObservationId: Map<string, readonly Component[]>): void;
+    sendCompletionNotification(): void;
+    handleBackgroundEvent(event: AgentSessionEvent): Promise<void>;
+}