@prometheus-ai/agent 0.5.3 → 0.5.8

package/dist/types/memory-backend/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Memory backend abstraction.
  *
- * Backends are mutually exclusive — `resolveMemoryBackend(settings)` returns
+ * Backends are mutually exclusive — `await resolveMemoryBackend(settings)` returns
  * exactly one. Implementations MUST be self-contained: they own the per-session
  * state they create in `start()` and tear it down on `clear()`.
  */
@@ -11,7 +11,66 @@ import type { Settings } from "../config/settings";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { MnemopiSessionState } from "../mnemopi/state";
 import type { AgentSession } from "../session/agent-session";
-export type MemoryBackendId = "off" | "local" | "hindsight" | "prometheus-memory";
+export type MemoryBackendId = "off" | "local" | "hindsight" | "mnemopi";
+export interface MemoryBackendStatus {
+    backend: MemoryBackendId;
+    active: boolean;
+    writable: boolean;
+    searchable: boolean;
+    scope?: string;
+    retainBank?: string;
+    recallBanks?: string[];
+    workingCount?: number;
+    episodicCount?: number;
+    tripleCount?: number;
+    lastMemory?: string;
+    lastRecall?: boolean;
+    database?: string;
+    message?: string;
+    error?: string;
+}
+export interface MemoryBackendSearchOptions {
+    limit?: number;
+    /** Best-effort abort signal. Backends may only observe it before/after an underlying recall call. */
+    signal?: AbortSignal;
+}
+export interface MemoryBackendSearchItem {
+    id?: string;
+    content: string;
+    source?: string;
+    timestamp?: string;
+    score?: number;
+}
+export interface MemoryBackendSearchResult {
+    backend: MemoryBackendId;
+    query: string;
+    count: number;
+    items: MemoryBackendSearchItem[];
+    message?: string;
+}
+export interface MemoryBackendSaveInput {
+    content: string;
+    context?: string;
+    source?: string;
+    importance?: number;
+}
+export interface MemoryBackendSaveResult {
+    backend: MemoryBackendId;
+    stored: number;
+    ids?: string[];
+    queued?: boolean;
+    message?: string;
+}
+export interface MemoryBackendOperationContext {
+    agentDir: string;
+    cwd: string;
+    session?: AgentSession;
+}
+export interface MemoryRuntimeContext {
+    status(): Promise<MemoryBackendStatus>;
+    search(query: string, options?: MemoryBackendSearchOptions): Promise<MemoryBackendSearchResult>;
+    save(input: string | MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
+}
 export interface MemoryBackendStartOptions {
     session: AgentSession;
     settings: Settings;
@@ -40,6 +99,12 @@ export interface MemoryBackend {
     clear(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
     /** Force consolidation/retain to happen now (slash `/memory enqueue`). */
     enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /** Structured state for UI, slash commands, and extensions. */
+    status?(context: MemoryBackendOperationContext): Promise<MemoryBackendStatus>;
+    /** Explicit user-facing semantic/lexical search. */
+    search?(context: MemoryBackendOperationContext, query: string, options?: MemoryBackendSearchOptions): Promise<MemoryBackendSearchResult>;
+    /** Explicit user-facing save operation. */
+    save?(context: MemoryBackendOperationContext, input: MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
     /** Render backend-specific memory statistics as markdown (`/memory stats`). */
     stats?(agentDir: string, cwd: string, session?: AgentSession): Promise<string | undefined>;
     /** Render backend-specific memory diagnostics as markdown (`/memory diagnose`). */

package/dist/types/mnemopi/config.d.ts

@@ -2,7 +2,7 @@ import type { MnemopiOptions } from "@prometheus-ai/memory";
 import type { Settings } from "../config/settings";
 export type MnemopiLlmMode = "none" | "smol" | "remote";
 export type MnemopiScoping = "global" | "per-project" | "per-project-tagged";
-export type MnemopiProviderOptions = Pick<MnemopiOptions, "noEmbeddings" | "embeddingModel" | "embeddingApiUrl" | "embeddingApiKey" | "llm">;
+export type MnemopiProviderOptions = Pick<MnemopiOptions, "noEmbeddings" | "embeddingModel" | "embeddingApiUrl" | "embeddingApiKey" | "llm" | "debug">;
 export interface MnemopiBackendConfig {
     dbPath: string;
     baseBank?: string;
@@ -13,6 +13,8 @@ export interface MnemopiBackendConfig {
     scoping?: MnemopiScoping;
     autoRecall: boolean;
     autoRetain: boolean;
+    polyphonicRecall: boolean;
+    enhancedRecall: boolean;
     retainEveryNTurns: number;
     recallLimit: number;
     recallContextTurns: number;
@@ -26,4 +28,32 @@ export interface MnemopiBackendConfig {
     llmModel?: string;
 }
 export declare function loadMnemopiConfig(settings: Settings, agentDir: string): MnemopiBackendConfig;
+export interface MnemopiBankScope {
+    baseBank: string;
+    bank: string;
+    globalBank: string;
+    retainBank: string;
+    recallBanks: readonly string[];
+}
+/**
+ * Resolve write/recall banks for a session.
+ *
+ * Mnemopi has no tag-filtered recall, so `per-project-tagged` maps to a
+ * project-local write bank plus a shared recall-visible bank. The project
+ * bank is derived purely from {@link cwd} — see {@link projectBank} for the
+ * stability contract.
+ */
+export declare function computeMnemopiBankScope(configured: string | undefined, cwd: string, scoping: MnemopiScoping): MnemopiBankScope;
+/**
+ * Discover sibling banks under `<dbDir>/banks/` whose `working_memory` rows
+ * all carry the active `cwd` in `metadata_json.$.cwd`, and add those safe
+ * single-cwd banks to the recall set. This rescues memories stranded by a
+ * previous, less-stable bank derivation (#2412) without recalling mixed-cwd
+ * legacy banks wholesale under per-project isolation.
+ *
+ * Robust by design: a missing banks directory, unreadable bank dir, or
+ * corrupt SQLite file is silently skipped. Scanning is capped at
+ * {@link LEGACY_BANK_SCAN_LIMIT} to bound startup cost.
+ */
+export declare function extendRecallWithLegacyBanks(resolved: readonly string[], dbPath: string, cwd: string): readonly string[];
 export declare function truncateApproxTokens(text: string, tokenLimit: number): string;

package/dist/types/mnemopi/state.d.ts

@@ -1,7 +1,17 @@
 import type { AgentMessage } from "@prometheus-ai/agent-core";
-import { Mnemopi, type RecallResult } from "@prometheus-ai/memory";
+import type * as MnemopiNs from "@prometheus-ai/memory";
+import type { Mnemopi, RecallResult } from "@prometheus-ai/memory";
+import type * as MnemopiCoreNs from "@prometheus-ai/memory/core";
 import type { AgentSession } from "../session/agent-session";
 import type { MnemopiBackendConfig } from "./config";
+/** Lazily load `@prometheus-ai/memory` (memoized). */
+export declare function loadMnemopi(): Promise<typeof MnemopiNs>;
+/** Lazily load `@prometheus-ai/memory/core` (memoized). */
+export declare function loadMnemopiCore(): Promise<typeof MnemopiCoreNs>;
+/** Sync access for code below an async boundary that already awaited {@link loadMnemopi}. */
+export declare function requireMnemopi(): typeof MnemopiNs;
+/** Sync access for code below an async boundary that already awaited {@link loadMnemopiCore}. */
+export declare function requireMnemopiCore(): typeof MnemopiCoreNs;
 interface MnemopiScopedMemory {
     bank: string;
     memory: Mnemopi;
@@ -65,7 +75,35 @@ export declare class MnemopiSessionState {
     }>, sourceId: string): Promise<void>;
     attachSessionListeners(): void;
     maybeRecallOnAgentStart(): Promise<void>;
-    dispose(): void;
+    /**
+     * Drain in-flight fact extraction and run beam consolidation on every owned
+     * bank, after capturing the current transcript. Mirrors the manual
+     * `/memory enqueue` slash command, but stops short of closing the DBs so
+     * callers can keep using the state. {@link dispose} composes this with the
+     * close step so normal session shutdown promotes working memory to
+     * episodic/gists/graph automatically (see issue #2320).
+     *
+     * Aliased subagent states share `scoped` (and therefore the actual SQLite
+     * banks) with their parent. `consolidate()` deliberately does NOT
+     * short-circuit on `aliasOf`: `forceRetainCurrentSession` already guards
+     * itself, and an explicit `/memory enqueue` invoked from within a subagent
+     * still needs to flush extractions and sleep the parent's shared banks —
+     * otherwise enqueue would report success while leaving the subagent's
+     * retained memories unconsolidated until the parent eventually shuts down
+     * (PR #2327 review).
+     */
+    consolidate(): Promise<void>;
+    /**
+     * Release the per-session resources. Defaults to running {@link consolidate}
+     * before closing handles so normal session shutdown promotes working memory
+     * into long-term storage. Callers that are about to delete the DB files —
+     * e.g. `mnemopiBackend.clear` — pass `{ consolidate: false }` to skip the
+     * extraction/sleep pass, since spending tokens on memories that will be
+     * wiped on the next line is wasted work (PR #2327 review).
+     */
+    dispose(options?: {
+        consolidate?: boolean;
+    }): Promise<void>;
 }
 export declare function getMnemopiScopedDbPaths(config: MnemopiBackendConfig): readonly string[];
 export declare function getMnemopiScopedBanks(config: MnemopiBackendConfig): readonly string[];

package/dist/types/modes/acp/acp-agent.d.ts

@@ -1,4 +1,4 @@
-import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModelRequest, type SetSessionModelResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
 import { type ExtensionUIContext } from "../../extensibility/extensions";
 import type { AgentSession } from "../../session/agent-session";
 /**
@@ -42,7 +42,6 @@ export declare class AcpAgent implements Agent {
     closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
     setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
     setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
-    unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse>;
     prompt(params: PromptRequest): Promise<PromptResponse>;
     cancel(params: {
         sessionId: string;

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -1,3 +1,19 @@
+/**
+ * AgentDashboard - dedicated control center for Task subagent configuration.
+ *
+ * Layout:
+ * - Top: source tabs (All, Project, User, Bundled)
+ * - Body: two-column view (agent list + inspector)
+ *
+ * Controls:
+ * - Up/Down or j/k: move selection
+ * - Tab / Shift+Tab or Left/Right: switch source tab
+ * - Space: enable/disable selected agent
+ * - Enter: edit model override for selected agent
+ * - N: start agent creation flow
+ * - Esc: clear search (if any) or close dashboard
+ * - Ctrl+R: reload discovered agents
+ */
 import { Container } from "@prometheus-ai/tui";
 import type { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
@@ -16,7 +32,7 @@ export declare class AgentDashboard extends Container {
     onRequestRender?: () => void;
     private constructor();
     static create(cwd: string, settings?: Settings | null, terminalHeight?: number, modelContext?: AgentDashboardModelContext): Promise<AgentDashboard>;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
 }
 export {};

package/dist/types/modes/components/agent-hub.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Agent Hub overlay component.
+ *
+ * One overlay, two views:
+ * - Table view: every registered agent except Main (Main IS the ambient
+ *   chat), live from the global AgentRegistry — status, unread irc count,
+ *   current/last task, last activity. Select with j/k, Enter opens a chat,
+ *   `r` revives a parked agent, `x` aborts + releases one.
+ * - Chat view: per-agent transcript (incremental session-file tail, absorbed
+ *   from the old session observer overlay) plus an input line. Submitting
+ *   revives a parked agent, then prompts/steers it; the message lands in the
+ *   agent's persisted history via the normal prompt path.
+ *
+ * Replaces the old SessionObserverOverlayComponent (ctrl+s observer).
+ */
+import type { AgentTool } from "@prometheus-ai/agent-core";
+import { Container, type TUI } from "@prometheus-ai/tui";
+import type { KeyId } from "../../config/keybindings";
+import type { MessageRenderer } from "../../extensibility/extensions/types";
+import { IrcBus } from "../../irc/bus";
+import { AgentLifecycleManager } from "../../registry/agent-lifecycle";
+import { AgentRegistry } from "../../registry/agent-registry";
+import type { SessionObserverRegistry } from "../session-observer-registry";
+/** Guest-side proxy for hub actions executed on the collab host. */
+export interface AgentHubRemote {
+    chat(id: string, text: string): void;
+    kill(id: string): void;
+    revive(id: string): void;
+    /** Mirrors readFileIncremental: text from fromByte (complete JSONL lines), newSize = next fromByte base; null = unavailable. */
+    readTranscript(id: string, fromByte: number): Promise<{
+        text: string;
+        newSize: number;
+    } | null>;
+}
+export interface AgentHubDeps {
+    /** Progress/status snapshot source (task lifecycle + progress channels). */
+    observers: SessionObserverRegistry;
+    /** Keys that toggle the hub closed from inside (app.agents.hub + app.session.observe). */
+    hubKeys: KeyId[];
+    onDone: () => void;
+    requestRender: () => void;
+    /** Injectable for tests; defaults to the process-global registry. */
+    registry?: AgentRegistry;
+    /** Injectable for tests; defaults to the process-global lifecycle manager. */
+    lifecycle?: AgentLifecycleManager;
+    /** Injectable for tests; defaults to the process-global bus. */
+    irc?: IrcBus;
+    /** TUI handle for transcript components; tests omit it and get a render-only stub. */
+    ui?: TUI;
+    /** Tool lookup for transcript renderers (labels, custom render functions). */
+    getTool?: (name: string) => AgentTool | undefined;
+    /** Extension message renderers for custom messages in the transcript. */
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    /** Cwd used by tool renderers for path shortening; defaults to the project dir. */
+    cwd?: string;
+    /** Mirrors the main transcript's thinking-block visibility. */
+    hideThinkingBlock?: () => boolean;
+    /** Keys toggling tool output expansion (app.tools.expand). */
+    expandKeys?: KeyId[];
+    /** Focus the main view on this agent's live session (ctx.focusAgentSession). When absent (collab guest, tests), Enter opens the in-hub chat view instead. */
+    focusAgent?: (id: string) => Promise<void>;
+    /** Current main session file; used to seed parked historical subagents after restart. */
+    sessionFile?: string | null;
+    /** Collab guest: route actions/transcripts to the host instead of local sessions. */
+    remote?: AgentHubRemote;
+}
+export declare class AgentHubOverlayComponent extends Container {
+    #private;
+    constructor(deps: AgentHubDeps);
+    /**
+     * Whether the table view has no agents to show (every registered agent except
+     * Main, after the persisted-subagent scan in the constructor). The double-←
+     * gesture reads this to stay inert when there is nothing to open.
+     */
+    get isEmpty(): boolean;
+    /** Tear down every subscription and timer. Called by the overlay owner on close. */
+    dispose(): void;
+    render(width: number): readonly string[];
+    handleInput(keyData: string): void;
+    /** Open the chat view for an agent id (public for table Enter and tests). */
+    openChat(id: string): void;
+}

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

@@ -1,4 +1,4 @@
-import type { AssistantMessage, ImageContent, Usage } from "@prometheus-ai/ai";
+import type { AssistantMessage, ImageContent } from "@prometheus-ai/ai";
 import { Container, type ImageBudget } from "@prometheus-ai/tui";
 import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 /**
@@ -19,17 +19,10 @@ export declare class AssistantMessageComponent extends Container {
      */
     setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
-    /**
-     * Assistant text/thinking streams in append-only: earlier rendered rows never
-     * re-layout, new content only grows the block at the bottom. The transcript
-     * reports this so the renderer may commit scrolled-off head rows of a long
-     * streamed reply to native scrollback instead of dropping them (see
-     * `NativeScrollbackLiveRegion#getNativeScrollbackCommitSafeEnd`). Volatile
-     * blocks (tool previews that collapse) intentionally do not implement this.
-     */
-    isTranscriptBlockAppendOnly(): boolean;
+    getTranscriptBlockVersion(): number;
     markTranscriptBlockFinalized(): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
-    setUsageInfo(usage: Usage): void;
-    updateContent(message: AssistantMessage): void;
+    updateContent(message: AssistantMessage, opts?: {
+        transient?: boolean;
+    }): void;
 }

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

@@ -17,7 +17,7 @@ export declare class BashExecutionComponent extends Container {
         output?: string;
         truncation?: TruncationMeta;
     }): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     /**
      * Get the raw output for creating BashExecutionMessage.
      */

package/dist/types/modes/components/chat-block.d.ts

@@ -0,0 +1,64 @@
+import { Container } from "@prometheus-ai/tui";
+/**
+ * Capabilities a mounted {@link ChatBlock} may use against its host transcript.
+ * Kept minimal so blocks never reach into the full TUI/InteractiveMode surface.
+ */
+export interface ChatBlockHost {
+    /** Schedule a repaint of the transcript. */
+    requestRender(): void;
+}
+/**
+ * Lifecycle-aware transcript block — the "return a block, let the host mount it"
+ * primitive, modelled on React/Svelte component lifecycles.
+ *
+ * Producers build and return a `ChatBlock` instead of poking `chatContainer` and
+ * `ui.requestRender()` directly. The host (`ctx.present`) appends it and calls
+ * {@link mount}, which runs {@link onMount}; effects started there register
+ * teardown via {@link onCleanup}. The block repaints through {@link requestRender}
+ * — never touching the TUI — and tears down exactly once on {@link finish}
+ * (self-complete: stop the animation, keep the final frame in the transcript) or
+ * {@link dispose} (host discards it, e.g. a transcript reset).
+ *
+ * While mounted and unfinished a block reports `isTranscriptBlockFinalized() ===
+ * false` so {@link "../components/transcript-container".TranscriptContainer}
+ * keeps it in the live, repaintable region on ED3-risk terminals; after
+ * `finish()`/`dispose()` it reports `true` and freezes at its final content.
+ */
+export declare abstract class ChatBlock extends Container {
+    #private;
+    /**
+     * Run setup after the block is in the transcript: start timers/subscriptions
+     * and register their teardown with {@link onCleanup}. Default: no-op (a block
+     * whose content is fixed at construction needs no mount work).
+     */
+    protected onMount(): void;
+    /**
+     * Register a teardown to run on {@link finish}/{@link dispose}, à la a
+     * `useEffect` cleanup. If the block is already disposed the cleanup runs
+     * immediately so callers never leak.
+     */
+    protected onCleanup(cleanup: () => void): void;
+    /** Ask the host to repaint. No-op before mount or after dispose. */
+    protected requestRender(): void;
+    /** True between {@link mount} and {@link finish}/{@link dispose}. */
+    protected get active(): boolean;
+    /**
+     * Host-only: attach the host and run {@link onMount}. Idempotent — a second
+     * call (e.g. a transcript rebuild that re-presents the same instance) is a
+     * no-op.
+     */
+    mount(host: ChatBlockHost): void;
+    /**
+     * Self-complete: stop ongoing effects and freeze the block at its current
+     * content, leaving it rendered in the transcript. Use when the operation the
+     * block represents finishes (connection resolved, download done).
+     */
+    finish(): void;
+    /**
+     * Host-only teardown: release everything and propagate to children. Called
+     * when the host permanently discards the block (transcript reset). Idempotent.
+     */
+    dispose(): void;
+    /** Live blocks stay repaintable; finished/disposed ones may freeze. */
+    isTranscriptBlockFinalized(): boolean;
+}

package/dist/types/modes/components/collab-prompt-message.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "@prometheus-ai/tui";
+import type { CollabPromptDetails } from "../../collab/protocol";
+import type { CustomMessage } from "../../session/messages";
+/**
+ * Renders a collab guest prompt on every participant's transcript: a
+ * user-message-styled bubble prefixed with the author's name.
+ */
+export declare class CollabPromptMessageComponent extends Container {
+    constructor(message: CustomMessage<CollabPromptDetails>);
+}

package/dist/types/modes/components/compaction-summary-message.d.ts

@@ -1,13 +1,33 @@
-import { Box } from "@prometheus-ai/tui";
-import type { CompactionSummaryMessage } from "../../session/messages";
+import { type Component } from "@prometheus-ai/tui";
+import type { CompactionSummaryMessage, CustomMessage } from "../../session/messages";
 /**
- * Component that renders a compaction message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 compacted · ctrl+o ────────
+ *
+ * The conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
  */
-export declare class CompactionSummaryMessageComponent extends Box {
+export declare class CompactionSummaryMessageComponent implements Component {
     #private;
     private readonly message;
     constructor(message: CompactionSummaryMessage);
     setExpanded(expanded: boolean): void;
     invalidate(): void;
+    render(width: number): readonly string[];
 }
+/**
+ * Handoff is a compaction strategy too, but it is persisted as a custom message
+ * so the LLM sees the handoff-specific developer context. Render it with the
+ * same divider affordance as `/compact` instead of the generic `[handoff]` box.
+ */
+export declare class HandoffSummaryMessageComponent implements Component {
+    #private;
+    private readonly message;
+    constructor(message: CustomMessage<unknown>);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    render(width: number): readonly string[];
+}
+export declare function createHandoffSummaryMessageComponent(message: CustomMessage<unknown>, expanded: boolean): HandoffSummaryMessageComponent | undefined;

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

@@ -18,5 +18,5 @@ export declare class CopySelectorComponent implements Component {
     constructor(roots: CopyTarget[], callbacks: CopySelectorCallbacks);
     invalidate(): void;
     handleInput(keyData: string): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,16 +1,50 @@
 import { Editor, type KeyId } from "@prometheus-ai/tui";
 import type { AppKeybinding } from "../../config/keybindings";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+/** Plain spaces from one auto-repeat run that trigger the space-hold push-to-talk STT gesture.
+ *  Holding the space bar makes the terminal emit a burst of spaces; once more than this many land
+ *  in the editor we treat it as "space held", track them back out, and start recording. */
+export declare const SPACE_HOLD_THRESHOLD = 5;
+/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
+ *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
+export declare const SPACE_HOLD_RELEASE_MS = 250;
+export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
+export declare function extractBracketedImagePastePath(data: string): string | undefined;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
 export declare class CustomEditor extends Editor {
     #private;
     imageLinks?: readonly (string | undefined)[];
-    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflow" keywords as the user types
+    /** Treat image/paste markers as indivisible: a stray backspace deletes the whole token
+     *  instead of corrupting `[Paste #1, +30 lines]` into plain text. */
+    atomicTokenPattern: RegExp;
+    /** Magic-keyword shimmer cadence — drives one editor repaint every 70 ms while
+     *  a keyword is on screen and the prompt is focused. ~14 frames/s is smooth
+     *  without flooding the renderer. */
+    static readonly SHIMMER_FRAME_MS = 70;
+    /** Time for the gradient to sweep one full cycle across each keyword. */
+    static readonly SHIMMER_PERIOD_MS = 1800;
+    /** Gradient-highlight the "ultrathink" / "orchestrate" / "workflowz" keywords as the user types
      *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. Also make
-     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists. */
+     *  pasted image placeholders visually distinct and hyperlink them once their blob file exists.
+     *  When the editor is focused, the buffer contains a magic keyword, and `magicKeywords.enabled`
+     *  is on, the gradient shifts every frame to produce a Claude-Code-style shimmer; each render
+     *  schedules the next frame, so losing focus, deleting the keyword, or flipping the setting
+     *  stops the animation on its own. The static glow itself runs even when shimmering is gated
+     *  off, matching existing behavior for the editor and sent bubbles. */
     decorateText: (text: string) => string;
+    /** Optional test/host override for the magic-keyword shimmer gate. When
+     *  defined, takes precedence over the global `magicKeywords.enabled` setting,
+     *  letting tests assert the gating behaviour without mutating the
+     *  process-wide Settings singleton (which races with parallel test files —
+     *  see issue #2582). Production wires this through the host's Settings
+     *  reader and updates it on the relevant setting change. */
+    magicKeywordsEnabledOverride: boolean | undefined;
+    /** Bind the host's render request callback. Idempotent — the host wires this
+     *  once after construction (and again after `setEditorComponent` swaps the
+     *  editor). Passing `undefined` clears any pending frame. */
+    setShimmerRepaintHandler(handler: (() => void) | undefined): void;
     onEscape?: () => void;
     onClear?: () => void;
     onExit?: () => void;
@@ -29,12 +63,25 @@ export declare class CustomEditor extends Editor {
     onCopyPrompt?: () => void;
     /** Called when the configured image-paste shortcut is pressed. */
     onPasteImage?: () => Promise<boolean>;
+    /** Called when a bracketed paste contains one or more image-file paths. */
+    onPasteImagePath?: (path: string) => void | Promise<void>;
     /** Called when the configured raw text-paste shortcut is pressed. */
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */
     onDequeue?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
+    /** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
+    onLeftAtStart?: () => void;
+    /** Fired when a sustained space-bar hold is recognized — the push-to-talk STT start. The
+     *  optimistically-typed spaces have already been deleted by the time this runs. */
+    onSpaceHoldStart?: () => void;
+    /** Fired when the held space bar is released (detected as an idle gap with no further repeated
+     *  spaces) — the push-to-talk STT stop. */
+    onSpaceHoldEnd?: () => void;
+    /** Gate for the space-hold gesture. Returns false to keep the space bar inserting spaces
+     *  normally; wired to `stt.enabled` so disabling STT restores plain space behavior. */
+    sttHoldEnabled?: () => boolean;
     setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void;
     /**
      * Register a custom key handler. Extensions use this for shortcuts.

package/dist/types/modes/components/custom-editor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modes/components/dynamic-border.d.ts

@@ -10,5 +10,5 @@ export declare class DynamicBorder implements Component {
     #private;
     constructor(color?: (str: string) => string);
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/modes/components/extensions/extension-dashboard.d.ts

@@ -22,6 +22,6 @@ export declare class ExtensionDashboard extends Container {
     onRequestRender?: () => void;
     private constructor();
     static create(cwd: string, settings?: Settings | null, terminalHeight?: number): Promise<ExtensionDashboard>;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
 }

package/dist/types/modes/components/extensions/extension-list.d.ts

@@ -34,6 +34,6 @@ export declare class ExtensionList implements Component {
     setSearchQuery(query: string): void;
     clearSearch(): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
     handleInput(data: string): void;
 }

package/dist/types/modes/components/extensions/inspector-panel.d.ts

@@ -4,5 +4,5 @@ export declare class InspectorPanel implements Component {
     #private;
     setExtension(extension: Extension | null): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

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

@@ -26,5 +26,5 @@ export declare class FooterComponent implements Component {
      */
     dispose(): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

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

@@ -15,4 +15,9 @@ export declare class HookEditorComponent extends Container {
     #private;
     constructor(tui: TUI, title: string, prefill: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, options?: HookEditorOptions);
     handleInput(keyData: string): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner editor, mirroring bracketed-paste semantics. Without this hook,
+     *  enhanced-paste routing falls back to the main prompt editor hidden behind the
+     *  dialog (#2127 routing contract). */
+    pasteText(text: string): void;
 }

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

@@ -11,5 +11,9 @@ export declare class HookInputComponent extends Container {
     #private;
     constructor(title: string, _placeholder: string | undefined, onSubmit: (value: string) => void, onCancel: () => void, opts?: HookInputOptions);
     handleInput(keyData: string): void;
+    /** Route non-bracketed paste transports (e.g. kitty's OSC 5522 enhanced clipboard)
+     *  into the inner input, mirroring bracketed-paste semantics. Pasting counts as
+     *  interaction, so the timeout countdown resets like any keystroke. */
+    pasteText(text: string): void;
     dispose(): void;
 }