jeopi-cli 16.2.14 → 16.2.15

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

@@ -0,0 +1,399 @@
+import type { AgentMessage } from "jeopi-agent-core";
+import type { CompactionOutcome } from "jeopi-agent-core/compaction";
+import type { AssistantMessage, ImageContent, Message, Usage, UsageReport } from "jeopi-ai";
+import type { Component, Container, EditorTheme, Loader, Spacer, Text, TUI } from "jeopi-tui";
+import type { CollabGuestLink } from "../collab/guest";
+import type { CollabHost } from "../collab/host";
+import type { KeybindingsManager } from "../config/keybindings";
+import type { Settings } from "../config/settings";
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionUISelectItem, ExtensionWidgetContent, ExtensionWidgetOptions } from "../extensibility/extensions";
+import type { CompactOptions } from "../extensibility/extensions/types";
+import type { Skill } from "../extensibility/skills";
+import type { MCPManager } from "../mcp";
+import type { PlanApprovalDetails } from "../plan-mode/approved-plan";
+import type { AgentSession } from "../session/agent-session";
+import type { CompactMode } from "../session/compact-modes";
+import type { HistoryStorage } from "../session/history-storage";
+import type { SessionContext } from "../session/session-context";
+import type { SessionManager } from "../session/session-manager";
+import type { ShakeMode } from "../session/shake-types";
+import type { LspStartupServerInfo } from "../tools";
+import type { EventBus } from "../utils/event-bus";
+import type { AssistantMessageComponent } from "./components/assistant-message";
+import type { BashExecutionComponent } from "./components/bash-execution";
+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, HookSelectorOptions } from "./components/hook-selector";
+import type { StatusLineComponent } from "./components/status-line";
+import type { ToolExecutionHandle } from "./components/tool-execution";
+import type { TranscriptContainer } from "./components/transcript-container";
+import type { EventController } from "./controllers/event-controller";
+import type { LoopLimitRuntime } from "./loop-limit";
+import type { OAuthManualInputManager } from "./oauth-manual-input";
+import type { Theme } from "./theme/theme";
+export type CompactionQueuedMessage = {
+    text: string;
+    mode: "steer" | "followUp";
+    images?: ImageContent[];
+};
+export type SubmittedUserInput = {
+    text: string;
+    images?: ImageContent[];
+    imageLinks?: (string | undefined)[];
+    customType?: string;
+    /** Route through `session.prompt(text, { synthetic: true })` so the text lands
+     *  as a hidden agent-authored `developer` message rather than a visible user
+     *  turn. Used by the `c`/`.` continue shortcut. */
+    synthetic?: boolean;
+    /** Marks this submission as a deliberate user resume (set by the `.`/`c`
+     *  continue shortcut, which is also `synthetic`). Forwarded to
+     *  `session.prompt({ userInitiated })` so it clears advisor auto-resume
+     *  suppression even though it is synthetic. */
+    userInitiated?: boolean;
+    display?: boolean;
+    /** Queue intent if the session is (or becomes) busy when this submission is
+     *  dispatched: "steer" (interrupt the active turn) or "followUp" (process after
+     *  it). Normal user Enter carries "steer" to match the streaming-branch Enter;
+     *  background/continuation submits omit it and default to "followUp". */
+    streamingBehavior?: "steer" | "followUp";
+    cancelled: boolean;
+    started: 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 interface InteractiveModeInitOptions {
+    suppressWelcomeIntro?: boolean;
+    clearInitialTerminalHistory?: boolean;
+}
+export type InteractiveSelectorDialogOptions = ExtensionUIDialogOptions & Pick<HookSelectorOptions, "disabledIndices">;
+export interface InteractiveModeContext {
+    ui: TUI;
+    chatContainer: TranscriptContainer;
+    pendingMessagesContainer: Container;
+    statusContainer: Container;
+    todoContainer: Container;
+    subagentContainer: Container;
+    btwContainer: Container;
+    omfgContainer: Container;
+    errorBannerContainer: Container;
+    modelCycleContainer: Container;
+    editor: CustomEditor;
+    editorContainer: Container;
+    hookWidgetContainerAbove: Container;
+    hookWidgetContainerBelow: Container;
+    statusLine: StatusLineComponent;
+    session: AgentSession;
+    sessionManager: SessionManager;
+    /** Session the transcript/editor/status are attached to: the focused agent's, else `session`. */
+    readonly viewSession: AgentSession;
+    /** Id of the focused agent, undefined when the main session is attached. */
+    readonly focusedAgentId: string | undefined;
+    /** Focus the main view on an agent's live session (delegates to SessionFocusController.focusAgent). */
+    focusAgentSession(id: string): Promise<void>;
+    /** Focus the focused agent's parent session, falling back to main (delegates to focusParent). */
+    focusParentSession(): Promise<void>;
+    /** Return the view to the main session (delegates to SessionFocusController.unfocus). */
+    unfocusSession(): Promise<void>;
+    /** Clear loader, transient HUD/pending containers, streaming state, and pending tools. */
+    clearTransientSessionUi(): void;
+    settings: Settings;
+    keybindings: KeybindingsManager;
+    agent: AgentSession["agent"];
+    historyStorage?: HistoryStorage;
+    mcpManager?: MCPManager;
+    lspServers?: LspStartupServerInfo[];
+    collabHost?: CollabHost;
+    collabGuest?: CollabGuestLink;
+    eventController: EventController;
+    eventBus?: EventBus;
+    isInitialized: boolean;
+    /**
+     * `true` once `renderInitialMessages` has rendered the session transcript
+     * into `chatContainer` at least once.
+     *
+     * Extension chat-rebuilds (`ExtensionUiController.#applyCustomMessageDisplay`)
+     * are gated on this: rebuilding before the initial render would plant a
+     * session-derived component into the chat that `renderInitialMessages` then
+     * both re-renders from session entries AND re-appends via
+     * `preserveExistingChat`, duplicating the message (issue #1955).
+     */
+    initialChatRendered: boolean;
+    isBashMode: boolean;
+    toolOutputExpanded: boolean;
+    todoExpanded: boolean;
+    planModeEnabled: boolean;
+    goalModeEnabled: boolean;
+    goalModePaused: boolean;
+    loopModeEnabled: boolean;
+    loopPrompt?: string;
+    loopLimit?: LoopLimitRuntime;
+    planModePlanFilePath?: string;
+    hideThinkingBlock: boolean;
+    /**
+     * Effective thinking-block visibility: true when hidden by user setting OR
+     * thinking level is "off" before the session has produced displayable
+     * thinking content.
+     */
+    readonly effectiveHideThinkingBlock: boolean;
+    /** Whether this visible session has produced thinking content the user can reveal. */
+    readonly hasDisplayableThinkingContent: boolean;
+    /** Record a message whose thinking content makes Ctrl+T meaningful even at thinking level "off"; returns true on first observation. */
+    noteDisplayableThinkingContent(message: AgentMessage): boolean;
+    proseOnlyThinking: boolean;
+    compactionQueuedMessages: CompactionQueuedMessage[];
+    pendingTools: Map<string, ToolExecutionHandle>;
+    pendingBashComponents: BashExecutionComponent[];
+    bashComponent: BashExecutionComponent | undefined;
+    pendingPythonComponents: EvalExecutionComponent[];
+    pythonComponent: EvalExecutionComponent | undefined;
+    isPythonMode: boolean;
+    streamingComponent: AssistantMessageComponent | undefined;
+    streamingMessage: AssistantMessage | undefined;
+    /**
+     * Usage of the most recently rendered assistant turn, used to detect a
+     * prompt-cache invalidation on the next turn (cache footprint collapse).
+     * Reseeded by `renderSessionContext` on every rebuild/session switch.
+     */
+    lastAssistantUsage: Usage | undefined;
+    loadingAnimation: Loader | undefined;
+    autoCompactionLoader: Loader | undefined;
+    retryLoader: Loader | undefined;
+    unsubscribe?: () => void;
+    onInputCallback?: (input: SubmittedUserInput) => void;
+    optimisticUserMessageSignature: string | undefined;
+    locallySubmittedUserSignatures: Set<string>;
+    lastSigintTime: number;
+    lastEscapeTime: number;
+    lastLeftTapTime: number;
+    shutdownRequested: boolean;
+    /** True once `shutdown()` has started. Read-only from the context;
+     *  controllers use this to skip work that races with teardown. */
+    readonly isShuttingDown: 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(options?: InteractiveModeInitOptions): Promise<void>;
+    playWelcomeIntro(): void;
+    shutdown(): Promise<void>;
+    checkShutdownRequested(): Promise<void>;
+    setToolUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    initializeHookRunner(uiContext: ExtensionUIContext, hasUI: boolean): void;
+    setEditorComponent(factory: ((tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager) => CustomEditor) | undefined): void;
+    /**
+     * Mount transcript content and repaint once. The single sink for "show this in
+     * chat": producers build and return a `Component` (or a `ChatBlock` carrying
+     * its own lifecycle) and hand it here instead of touching `chatContainer` /
+     * `ui.requestRender()` directly. `ChatBlock`s are mounted (their `onMount`
+     * runs) so their timers/subscriptions start.
+     */
+    present(content: Component | readonly Component[]): void;
+    /**
+     * Dispose every live block in the transcript (stopping timers/subscriptions)
+     * and clear it. Used before a full rebuild so animated/streaming blocks do not
+     * leak.
+     */
+    resetTranscript(): void;
+    showStatus(message: string, options?: {
+        dim?: boolean;
+    }): void;
+    showModelCycleTrack(track: string): void;
+    showError(message: string): void;
+    showPinnedError(message: string): void;
+    clearPinnedError(): void;
+    showWarning(message: string): void;
+    showNewVersionNotification(newVersion: string): void;
+    clearEditor(): void;
+    updatePendingMessagesDisplay(): void;
+    queueCompactionMessage(text: string, mode: "steer" | "followUp", images?: ImageContent[]): void;
+    flushCompactionQueue(options?: {
+        willRetry?: boolean;
+    }): Promise<void>;
+    flushPendingBashComponents(): void;
+    flushPendingModelSwitch(): Promise<void>;
+    setWorkingMessage(message?: string): void;
+    applyPendingWorkingMessage(): void;
+    ensureLoadingAnimation(): void;
+    startPendingSubmission(input: {
+        text: string;
+        images?: ImageContent[];
+        imageLinks?: (string | undefined)[];
+        customType?: string;
+        display?: boolean;
+        streamingBehavior?: "steer" | "followUp";
+    }): 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>;
+    /** Clears bookkeeping for an optimistic local user message once the matching session event arrives. */
+    clearOptimisticUserMessage(): void;
+    /** Replaces the raw optimistic user render with the canonical message emitted by the session. */
+    replaceOptimisticUserMessage(message: AgentMessage, options?: {
+        imageLinks?: readonly (string | undefined)[];
+    }): void;
+    isKnownSlashCommand(text: string): boolean;
+    addMessageToChat(message: AgentMessage, options?: {
+        populateHistory?: boolean;
+        imageLinks?: readonly (string | undefined)[];
+    }): Component[];
+    renderSessionContext(sessionContext: SessionContext, options?: {
+        updateFooter?: boolean;
+        populateHistory?: boolean;
+    }): void;
+    renderInitialMessages(options?: {
+        preserveExistingChat?: boolean;
+        clearTerminalHistory?: boolean;
+    }): void;
+    getUserMessageText(message: Message): string;
+    findLastAssistantMessage(): AssistantMessage | undefined;
+    extractAssistantText(message: AssistantMessage): string;
+    /** Refresh the running-subagents status badge from the active local or collab registry. */
+    syncRunningSubagentBadge(): void;
+    updateEditorBorderColor(): void;
+    rebuildChatFromMessages(): void;
+    setTodos(todos: TodoItem[] | TodoPhase[]): void;
+    reloadTodos(): Promise<void>;
+    toggleTodoExpansion(): void;
+    handleExportCommand(text: string): Promise<void>;
+    handleShareCommand(): Promise<void>;
+    handleTodoCommand(args: string): Promise<void>;
+    handleSessionCommand(): Promise<void>;
+    handleAdvisorStatusCommand(): Promise<void>;
+    handleJobsCommand(): Promise<void>;
+    handleUsageCommand(reports?: UsageReport[] | null): Promise<void>;
+    handleChangelogCommand(showFull?: boolean): Promise<void>;
+    handleHotkeysCommand(): void;
+    handleToolsCommand(): void;
+    handleContextCommand(): void;
+    handleDumpCommand(): Promise<void>;
+    handleAdvisorDumpCommand(isRaw?: boolean): void;
+    handleDebugTranscriptCommand(): Promise<void>;
+    handleClearCommand(): Promise<void>;
+    handleFreshCommand(): Promise<void>;
+    handleDropCommand(): Promise<void>;
+    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, mode?: CompactMode): Promise<CompactionOutcome>;
+    handleHandoffCommand(customInstructions?: string): Promise<void>;
+    handleShakeCommand(mode: ShakeMode): 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;
+    refreshSlashCommandState(cwd?: string): Promise<void>;
+    applyCwdChange(newCwd: string): Promise<void>;
+    showSettingsSelector(): void;
+    showAdvisorConfigure(): void;
+    showHistorySearch(): void;
+    showExtensionsDashboard(): void;
+    showAgentsDashboard(): void;
+    showModelSelector(options?: {
+        temporaryOnly?: boolean;
+    }): void;
+    showPluginSelector(mode?: "install" | "uninstall"): void;
+    showUserMessageSelector(): void;
+    showCopySelector(): void;
+    showTreeSelector(): void;
+    showSessionSelector(): void;
+    handleResumeSession(sessionPath: string): Promise<void>;
+    handleSessionDeleteCommand(): Promise<void>;
+    showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
+    showResetUsageSelector(): Promise<void>;
+    showProviderSetup(): Promise<void>;
+    showHookConfirm(title: string, message: string): Promise<boolean>;
+    showDebugSelector(): Promise<void>;
+    showAgentHub(options?: {
+        requireContent?: boolean;
+    }): void;
+    resetObserverRegistry(): void;
+    handleCtrlC(): void;
+    handleCtrlD(): void;
+    handleCtrlZ(): void;
+    handleDequeue(): void;
+    handleImagePaste(): Promise<boolean>;
+    handleBtwCommand(question: string): Promise<void>;
+    handleTanCommand(work: string): Promise<void>;
+    hasActiveBtw(): boolean;
+    handleBtwEscape(): boolean;
+    handleBtwBranchKey(): Promise<boolean>;
+    canBranchBtw(): boolean;
+    canCopyBtw(): boolean;
+    handleBtwCopyKey(): Promise<boolean>;
+    handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
+    handleOmfgCommand(complaint: string): Promise<void>;
+    hasActiveOmfg(): boolean;
+    handleOmfgEscape(): boolean;
+    cycleThinkingLevel(): void;
+    cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
+    toggleToolOutputExpansion(): void;
+    setToolsExpanded(expanded: boolean): void;
+    toggleThinkingBlockVisibility(): void;
+    openExternalEditor(): void;
+    registerExtensionShortcuts(): void;
+    handlePlanModeCommand(initialPrompt?: string): Promise<void>;
+    handleGoalModeCommand(rest?: string): Promise<void>;
+    handleGuidedGoalCommand(rest?: string): Promise<void>;
+    handleLoopCommand(args?: string): Promise<string | undefined>;
+    disableLoopMode(): void;
+    pauseLoop(): void;
+    handlePlanApproval(details: PlanApprovalDetails): Promise<void>;
+    openPlanReview(): Promise<void>;
+    initHooksAndCustomTools(): Promise<void>;
+    emitCustomToolSessionEvent(reason: "start" | "switch" | "branch" | "tree" | "shutdown", previousSessionFile?: string): Promise<void>;
+    setHookWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    setHookStatus(key: string, text: string | undefined): void;
+    showHookSelector(title: string, options: ExtensionUISelectItem[], dialogOptions?: InteractiveSelectorDialogOptions): Promise<string | undefined>;
+    hideHookSelector(): void;
+    showHookInput(title: string, placeholder?: 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;
+}

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

@@ -0,0 +1,15 @@
+import { type KeywordHighlighter } from "./gradient-highlight";
+/** Hidden system notice appended after a user message that mentions "ultrathink". */
+export declare const ULTRATHINK_NOTICE: string;
+/**
+ * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
+ * whitespace-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export declare function containsUltrathink(text: string): boolean;
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
+ */
+export declare const highlightUltrathink: KeywordHighlighter;

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

@@ -0,0 +1,64 @@
+import type { Model } from "jeopi-ai";
+import type { Skill } from "../../extensibility/skills";
+import type { AgentSession } from "../../session/agent-session";
+import { type SnapcompactSavingsEstimate } from "../../session/snapcompact-inline";
+import type { Tool } from "../../tools";
+import type { theme as Theme } from "../theme/theme";
+type CategoryId = "systemPrompt" | "systemContext" | "systemTools" | "skills" | "messages";
+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[];
+    usedTokens: number;
+    autoCompactBufferTokens: number;
+    freeTokens: number;
+    /** Estimated snapcompact wire savings; set when requested and a snapcompact.* setting is enabled. */
+    snapcompact?: SnapcompactSavingsEstimate;
+}
+export declare function estimateSkillsTokens(skills: readonly Skill[]): number;
+export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">>): number;
+/**
+ * Compute just the NON-MESSAGE token total: system prompt (with its skills
+ * section subtracted, since skills are tokenized separately) + system context
+ * (the rest of the system-prompt array) + tools + skills.
+ *
+ * Exposed so callers like `StatusLineComponent` can cache the non-message
+ * total separately from the message total. Non-message inputs (skills,
+ * tools, system prompt) change rarely; the message list grows on every
+ * streaming turn. Splitting the two lets the caller refresh each on its own
+ * cadence — non-message recomputed only when the inputs identity changes,
+ * messages walked incrementally as new entries append.
+ */
+export declare function computeNonMessageTokens(session: AgentSession): number;
+/**
+ * Shared helper for the four non-message token totals used by
+ * `computeContextBreakdown` (/context panel). Keep this category split stable:
+ * the status-line fast path intentionally uses the equivalent collapsed total
+ * in `computeNonMessageTokens`.
+ */
+export declare function computeNonMessageBreakdown(session: AgentSession): {
+    skillsTokens: number;
+    toolsTokens: number;
+    systemContextTokens: number;
+    systemPromptTokens: number;
+};
+/**
+ * Compute a breakdown of estimated context usage by category for the active
+ * session and model.
+ */
+export declare function computeContextBreakdown(session: AgentSession, options?: {
+    snapcompactSavings?: boolean;
+}): 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;
+export {};

package/dist/types/modes/utils/copy-targets.d.ts

@@ -0,0 +1,75 @@
+import type { AgentMessage } from "jeopi-agent-core";
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+    /** Info string after the opening fence (language id), trimmed. */
+    lang: string;
+    /** Block body with the trailing newline stripped. */
+    code: string;
+}
+/** A blockquote block: a maximal run of `>`-prefixed lines from markdown. */
+export interface QuoteBlock {
+    /** Block body with each line's `>` marker (and one optional space) removed. */
+    text: string;
+}
+/** A drillable block within an assistant message, in document order. */
+export type MessageBlock = ({
+    kind: "code";
+} & CodeBlock) | ({
+    kind: "quote";
+} & QuoteBlock);
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+    kind: "bash" | "eval";
+    code: string;
+    /** Highlight language: "bash" for bash, or the resolved eval language ("python"/"javascript"/"ruby"/"julia"). */
+    language: string;
+}
+/**
+ * A node in the `/copy` picker tree. Leaves carry `content` (placed on the
+ * clipboard) plus `copyMessage` (the status shown afterwards); groups carry
+ * `children` to drill into.
+ */
+export interface CopyTarget {
+    /** Stable id (e.g. "msg:1", "msg:1:code:0", "msg:1:quote:0", "msg:1:all", "cmd:1"). */
+    id: string;
+    label: string;
+    /** Dim annotation: line/block counts, language, or tool name. */
+    hint?: string;
+    /** Full text rendered in the preview pane. */
+    preview: string;
+    /** Highlight language for code/command previews (undefined = plain/markdown). */
+    language?: string;
+    /** Leaf: text copied to the clipboard. */
+    content?: string;
+    /** Leaf: status message shown after copying. */
+    copyMessage?: string;
+    /** Group: nested targets to drill into. */
+    children?: CopyTarget[];
+}
+/** Minimal session surface needed to assemble copy targets (eases testing). */
+export interface CopySource {
+    readonly messages: readonly AgentMessage[];
+    getLastVisibleHandoffText(): string | undefined;
+}
+/**
+ * Split assistant markdown into drillable blocks — fenced code and `>`-quoted
+ * runs — in document order. Fences mask their bodies, so a `>` line inside a
+ * code block is never mistaken for a quote. An unclosed fence is treated as
+ * ordinary text, matching the fenced-block grammar.
+ */
+export declare function extractBlocks(text: string): MessageBlock[];
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export declare function extractCodeBlocks(text: string): CodeBlock[];
+/** Walk the transcript backwards for the most recent fenced assistant code block. */
+export declare function extractLastCodeBlock(messages: readonly AgentMessage[]): CodeBlock | undefined;
+/** Extract `>`-quoted blocks from assistant markdown, in document order. */
+export declare function extractQuoteBlocks(text: string): QuoteBlock[];
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export declare function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined;
+/**
+ * Assemble the unified `/copy` target tree: recent assistant messages
+ * (most recent first, each drillable into its code blocks), runnable command
+ * targets interleaved after the assistant message that issued them, and a
+ * fresh-handoff fallback when no assistant message exists yet.
+ */
+export declare function buildCopyTargets(source: CopySource): CopyTarget[];

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/interactive-context-helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Small helpers over {@link InteractiveModeContext} shared between
+ * {@link UiHelpers} and the input/event controllers, so the live chat surfaces
+ * construct components and reset editor state identically.
+ */
+import type { AssistantMessage } from "jeopi-ai";
+import { AssistantMessageComponent } from "../components/assistant-message";
+import type { InteractiveModeContext } from "../types";
+/**
+ * Construct an {@link AssistantMessageComponent} wired to the live context's
+ * thinking/image settings. `message` is omitted for the streaming placeholder
+ * component and supplied when rendering a persisted turn.
+ */
+export declare function createAssistantMessageComponent(ctx: InteractiveModeContext, message?: AssistantMessage): AssistantMessageComponent;

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

@@ -0,0 +1,32 @@
+/**
+ * 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;
+/** Match the generic selector cancel keybinding. */
+export declare function matchesSelectCancel(data: string): boolean;
+/** Match the generic selector up-navigation keybinding. */
+export declare function matchesSelectUp(data: string): boolean;
+/** Match the generic selector down-navigation keybinding. */
+export declare function matchesSelectDown(data: string): boolean;
+/** Match the generic selector page-up keybinding. */
+export declare function matchesSelectPageUp(data: string): boolean;
+/** Match the generic selector page-down keybinding. */
+export declare function matchesSelectPageDown(data: string): boolean;
+export declare function matchesAppExternalEditor(data: string): boolean;
+/**
+ * Match the "submit multi-line text input" keybinding (`app.message.followUp`).
+ *
+ * Used by forms where plain Enter inserts a newline and a modified-Enter chord
+ * submits — the main editor's follow-up handler, the agent dashboard's new-agent
+ * description, and the hook editor's hook-style mode. The keybinding defaults to
+ * `["ctrl+q", "ctrl+enter"]` so Windows Terminal (which can't deliver a distinct
+ * Ctrl+Enter event; #1903) still has a working chord without user remapping.
+ *
+ * Also recognizes modifier-tagged LF as Ctrl+Enter only when Ctrl+Enter is an
+ * effective follow-up binding.
+ */
+export declare function matchesAppFollowUp(data: string): boolean;

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/transcript-render-helpers.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Render helpers shared between the live transcript ({@link UiHelpers}) and the
+ * file/remote-backed {@link ChatTranscriptBuilder}. Both surfaces build the same
+ * transcript rows from persisted message entries; holding the row construction
+ * here keeps the two byte-for-byte identical.
+ */
+import type { AgentMessage } from "jeopi-agent-core";
+import { type Component } from "jeopi-tui";
+import { type FileMentionMessage } from "../../session/messages";
+import { TranscriptBlock } from "../components/transcript-container";
+type CustomOrHookMessage = Extract<AgentMessage, {
+    role: "custom" | "hookMessage";
+}>;
+type AssistantAgentMessage = Extract<AgentMessage, {
+    role: "assistant";
+}>;
+/**
+ * Render an `async-result` custom message (a completed background bash/task job,
+ * or a batch of them) as a transcript block of one "Background job completed"
+ * row per job.
+ */
+export declare function buildAsyncResultBlock(message: CustomOrHookMessage): TranscriptBlock;
+/**
+ * Render a live IRC traffic custom message (`irc:incoming` / `irc:autoreply` /
+ * `irc:relay`) as a transcript card. `getExpanded` supplies the live
+ * expanded-state getter for the cached card.
+ */
+export declare function buildIrcMessageCard(message: CustomOrHookMessage, getExpanded: () => boolean): Component;
+/**
+ * Render a `fileMention` message's files as a transcript block of "Read <path>"
+ * rows. `indent` sets the left pad: the live chat renders within an outer gutter
+ * (0), the transcript viewer renders body rows without one so rows own their pad
+ * (1).
+ */
+export declare function buildFileMentionBlock(files: FileMentionMessage["files"], indent: number): TranscriptBlock;
+/**
+ * Whether an assistant turn has visible text or thinking content (after
+ * canonicalization) — i.e. content that closes the current read-tool run.
+ */
+export declare function assistantHasVisibleContent(message: AssistantAgentMessage): boolean;
+/**
+ * Normalize raw tool-call arguments to a plain record, collapsing non-object or
+ * array values to an empty object.
+ */
+export declare function normalizeToolArgs(args: unknown): Record<string, unknown>;
+/**
+ * Resolve the inline error label, if any, for a turn-ending assistant message.
+ * Silent aborts yield no label. `retryAttempt` tunes the abort label wording.
+ */
+export declare function resolveAssistantErrorMessage(message: AssistantAgentMessage, retryAttempt?: number): {
+    hasErrorStop: boolean;
+    errorMessage: string | null;
+};
+export {};