@prometheus-ai/agent 0.5.4 → 0.5.8

package/dist/types/session/session-migrations.d.ts

@@ -0,0 +1,12 @@
+import { type FileEntry } from "./session-entries";
+/** Generate a unique short ID (8 hex chars, collision-checked) */
+export declare function generateId(byId: {
+    has(id: string): boolean;
+}): string;
+/**
+ * Run all necessary migrations to bring entries to current version.
+ * Mutates entries in place. Returns true if any migration was applied.
+ */
+export declare function migrateToCurrentVersion(entries: FileEntry[]): boolean;
+/** Exported for testing */
+export declare function migrateSessionEntries(entries: FileEntry[]): void;

package/dist/types/session/session-paths.d.ts

@@ -0,0 +1,25 @@
+import type { SessionStorage } from "./session-storage";
+export declare function resolveManagedSessionRoot(sessionDir: string, cwd: string): string | undefined;
+/**
+ * Compute the default session directory for a cwd.
+ * Classifies cwd by canonical location so symlink/alias paths resolve to the
+ * same home-relative or temp-root directory names as their real targets.
+ */
+export declare function computeDefaultSessionDir(cwd: string, storage: SessionStorage, sessionsRoot?: string): string;
+/**
+ * Write a breadcrumb linking the current terminal to a session file.
+ * The breadcrumb contains the cwd and session path so --continue can
+ * find "this terminal's last session" even when running concurrent instances.
+ */
+export declare function writeTerminalBreadcrumb(cwd: string, sessionFile: string): void;
+export interface TerminalBreadcrumb {
+    cwd: string;
+    sessionFile: string;
+}
+/**
+ * Read the raw terminal breadcrumb for the current terminal.
+ * Returns the recorded cwd + session file (verified to exist) regardless of
+ * whether the recorded cwd still matches the current one. Callers decide how
+ * to interpret a cwd mismatch (e.g. a moved/renamed worktree).
+ */
+export declare function readTerminalBreadcrumbEntry(): Promise<TerminalBreadcrumb | null>;

package/dist/types/session/session-persistence.d.ts

@@ -0,0 +1,8 @@
+import { type BlobStore } from "./blob-store";
+import type { FileEntry } from "./session-entries";
+export declare function isImageBlock(value: unknown): value is {
+    type: "image";
+    data: string;
+    mimeType?: string;
+};
+export declare function prepareEntryForPersistence(entry: FileEntry, blobStore: BlobStore): FileEntry;

package/dist/types/session/session-storage.d.ts

@@ -4,17 +4,17 @@ export interface SessionStorageStat {
     mtime: Date;
 }
 export interface SessionStorageWriter {
-    writeLine(line: string): Promise<void>;
     /**
-     * Synchronously append a single line. Returns once the bytes are handed to the kernel
-     * (page cache), so the data survives a non-graceful process death (OOM, SIGKILL, etc.)
-     * even though it has not yet been fsynced to the underlying disk.
+     * Append one newline-terminated line. File and memory storage perform the
+     * write synchronously in-body; indexed backends queue in call order.
      *
-     * `line` MUST already include the trailing newline. Throws synchronously on I/O error.
+     * `line` MUST include the trailing newline.
      */
-    writeLineSync(line: string): void;
+    append(line: string): Promise<void>;
+    /** Resolve once all queued appends complete. No fsync. */
     flush(): Promise<void>;
-    fsync(): Promise<void>;
+    /** False once close() has begun/finished. */
+    isOpen(): boolean;
     close(): Promise<void>;
     getError(): Error | undefined;
 }
@@ -29,6 +29,7 @@ export interface SessionStorage {
     /** Read the requested UTF-8 byte windows from the head and tail of the file. */
     readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
+    writeTextAtomic(path: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;
     deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
@@ -38,6 +39,7 @@ export interface SessionStorage {
     }): SessionStorageWriter;
 }
 export declare class FileSessionStorage implements SessionStorage {
+    #private;
     ensureDirSync(dir: string): void;
     existsSync(path: string): boolean;
     writeTextSync(fpath: string, content: string): void;
@@ -47,6 +49,7 @@ export declare class FileSessionStorage implements SessionStorage {
     readText(path: string): Promise<string>;
     readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
+    writeTextAtomic(fpath: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;
     openWriter(path: string, options?: {
@@ -76,6 +79,7 @@ export declare class MemorySessionStorage implements SessionStorage {
     readText(path: string): Promise<string>;
     readTextSlices(path: string, prefixBytes: number, suffixBytes: number): Promise<[string, string]>;
     writeText(path: string, content: string): Promise<void>;
+    writeTextAtomic(path: string, content: string): Promise<void>;
     rename(path: string, nextPath: string): Promise<void>;
     unlink(path: string): Promise<void>;
     deleteSessionWithArtifacts(_sessionPath: string): Promise<void>;

package/dist/types/session/snapcompact-inline.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Snapcompact inline imaging: per-request transform that swaps the system
+ * prompt, loaded context-file instructions, and/or large historical tool
+ * results for dense PNG frames on vision-capable models.
+ * Runs inside the agent loop's `transformProviderContext` hook — after the
+ * persisted history is converted to the outgoing `Context`, before the
+ * provider stream call. It only ever builds NEW message objects/arrays; the
+ * input context shares `content` array references with the persisted
+ * `SessionMessageEntry` messages, so mutation would leak rendered images
+ * into session.jsonl.
+ *
+ * The swap policy (budget, savings gate, skip rules) lives in
+ * `planInlineSwaps`, shared by the transform and the `/context` savings
+ * estimate (`estimateInlineSavings`) so the two can never disagree.
+ */
+import type { Context, Model } from "@prometheus-ai/ai";
+import * as snapcompact from "@prometheus-ai/snapcompact";
+export type SnapcompactSystemPromptMode = "none" | "agents-md" | "all";
+export interface SnapcompactInlineOptions {
+    renderSystemPrompt: SnapcompactSystemPromptMode;
+    renderToolResults: boolean;
+    /** Frame variant override; `"auto"`/omitted picks the provider's eval winner. */
+    shape?: snapcompact.ShapeVariantName | "auto";
+}
+/**
+ * Reports the per-tool-result tokens kept off the wire when a swap is applied.
+ * `savedTokens` is `textTokens - frames * shape.frameTokenEstimate` for each
+ * imaged tool result (always > 0; the savings gate guarantees it). Wired to the
+ * append-only savings journal; never throws into the request path.
+ */
+export type SnapcompactSavingsSink = (savings: ReadonlyArray<{
+    toolCallId: string;
+    savedTokens: number;
+}>, model: Model) => void;
+/** Tool-result swap candidate, in context order. */
+export interface InlineToolResultCandidate {
+    /** Stable identifier for rendering cache key and applying the swap. */
+    id: string;
+    /** Token count of the joined text blocks (0 for empty or image-carrying). */
+    textTokens: number;
+    /** Frames needed to render the text (0 = empty, below floor, image-carrying, or error). */
+    frames: number;
+    /** Already carries an image (screenshot etc.) — never re-imaged. */
+    hasImage: boolean;
+    /** Error tool results must stay text-only for provider API validation. */
+    isError?: boolean;
+}
+export interface InlineSystemPromptCandidate {
+    textTokens: number;
+    frames: number;
+}
+export interface InlinePlanInput {
+    options: SnapcompactInlineOptions;
+    shape: snapcompact.Shape;
+    /** Provider image-count budget minus images already present in the context. */
+    budget: number;
+    /** All tool results in context order, INCLUDING the most recent one. */
+    toolResults: readonly InlineToolResultCandidate[];
+    /** Selected prompt text; undefined when system-prompt imaging is off or empty. */
+    systemPrompt: InlineSystemPromptCandidate | undefined;
+    /** Whether a user message exists to carry the prompt frames. */
+    hasUserMessage: boolean;
+}
+export interface InlineSwapPlan {
+    /** Tool results to swap, oldest first. */
+    toolResults: Array<{
+        id: string;
+        textTokens: number;
+        frames: number;
+    }>;
+    /** Set when the system prompt should swap to frames (uses leftover budget). */
+    systemPrompt: InlineSystemPromptCandidate | undefined;
+}
+/**
+ * Decide which content gets swapped for frames. Pure — the same rules drive
+ * the provider-request transform and the /context savings estimate.
+ */
+export declare function planInlineSwaps(input: InlinePlanInput): InlineSwapPlan;
+/**
+ * Minimal structural view of a history message — both @prometheus-ai/ai `Message`s (the
+ * outgoing context) and agent-core `AgentMessage`s (the live session) satisfy
+ * it, so the estimator can read session state without conversion.
+ */
+export interface InlineMessageView {
+    role: string;
+    toolCallId?: string;
+    content?: unknown;
+    isError?: boolean;
+}
+export interface SnapcompactSavingsEstimate {
+    /** Frames only ship on models that accept image input. */
+    visionCapable: boolean;
+    /** Present iff system-prompt imaging is enabled. */
+    systemPrompt?: {
+        applied: boolean;
+        /** Why the prompt stays text when `applied` is false. */
+        reason?: "empty" | "margin" | "budget";
+        textTokens: number;
+        frames: number;
+        /** Estimated billed tokens for the frames (0 when there are none). */
+        imageTokens: number;
+        savedTokens: number;
+        scope: Exclude<SnapcompactSystemPromptMode, "none">;
+    };
+    /** Present iff tool-result imaging is enabled. */
+    toolResults?: {
+        /** Tool results currently in history. */
+        total: number;
+        swapped: number;
+        /** Text tokens of the swapped results only. */
+        textTokens: number;
+        frames: number;
+        imageTokens: number;
+        savedTokens: number;
+    };
+    /** Net estimated wire savings for the next request. */
+    savedTokens: number;
+}
+/**
+ * Estimate what `SnapcompactInlineTransformer.transform` would save on the
+ * NEXT request, given the session's live system prompt and message history.
+ *
+ * Mirrors the transform exactly via `planInlineSwaps`, with one deliberate
+ * difference: `hasUserMessage` is assumed true, because the request being
+ * estimated is always triggered by a user prompt — even when the current
+ * history is still empty.
+ */
+export declare function estimateInlineSavings(input: {
+    options: SnapcompactInlineOptions;
+    model: Model | undefined;
+    systemPrompt: readonly string[];
+    messages: readonly InlineMessageView[];
+}): SnapcompactSavingsEstimate;
+/**
+ * Stateless with respect to the model (passed per call, so mid-session model
+ * switches re-resolve shape and budget); stateful only for the render caches,
+ * which live as long as the session's Agent.
+ */
+export declare class SnapcompactInlineTransformer {
+    #private;
+    private readonly options;
+    private readonly onToolResultSavings?;
+    constructor(options: SnapcompactInlineOptions, onToolResultSavings?: SnapcompactSavingsSink | undefined);
+    transform(context: Context, model: Model): Context;
+}

package/dist/types/session/snapcompact-savings-journal.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Append-only journal of snapcompact tool-result savings.
+ *
+ * Snapcompact frames are transient — built per provider request in
+ * `transformProviderContext` and never written to session.jsonl — so the tokens
+ * they keep off the wire would otherwise leave no trace. This records one line
+ * the FIRST time a tool result is imaged in a session:
+ *
+ *   {"ts":<epochMs>,"session":<sessionFile>,"provider":..,"model":..,"toolCallId":..,"savedTokens":..}
+ *
+ * Newline-delimited JSON, opened with O_APPEND so concurrent appenders (parallel
+ * agents/subagents) never interleave a partial line. Writes are fire-and-forget;
+ * a failure is logged at debug and never propagates into the request hot path.
+ *
+ * Readers MUST dedup by (session, toolCallId): a session resumed in a fresh
+ * process re-images the same results and may append a second line. The savings
+ * for a given (session, toolCallId) are stable, so any-per-key is correct.
+ */
+import type { Model } from "@prometheus-ai/ai";
+export interface SnapcompactSavingsRecord {
+    /** Epoch milliseconds when the swap was applied. */
+    ts: number;
+    /** Session file path (matches the stats `messages.session_file` key). */
+    session: string;
+    provider: string;
+    model: string;
+    toolCallId: string;
+    savedTokens: number;
+}
+/** `~/.prometheus/.../snapcompact-savings.jsonl`, colocated with stats.db. */
+export declare function snapcompactSavingsJournalPath(): string;
+/**
+ * Appends savings to the journal, deduped by toolCallId for the recorder's
+ * lifetime (one per session). Returns the in-flight append so callers/tests can
+ * await durability; the production transform leaves it floating (fire-and-forget,
+ * and it never rejects — I/O errors are swallowed to debug). `getSession` is read
+ * at write time so a session file assigned late is still captured; a null session
+ * (in-memory / SDK embedding) or non-positive savings skip the write.
+ */
+export type SnapcompactSavingsRecorder = (savings: ReadonlyArray<{
+    toolCallId: string;
+    savedTokens: number;
+}>, model: Model) => Promise<void>;
+export declare function createSnapcompactSavingsRecorder(getSession: () => string | null, journalPath?: string): SnapcompactSavingsRecorder;
+/** Read all journal records. Malformed lines are skipped; a missing file is empty. */
+export declare function readSnapcompactSavingsJournal(journalPath?: string): Promise<SnapcompactSavingsRecord[]>;

package/dist/types/session/streaming-output.d.ts

@@ -2,6 +2,15 @@ import type { AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 export declare const DEFAULT_MAX_LINES = 3000;
 export declare const DEFAULT_MAX_BYTES: number;
 export declare const DEFAULT_MAX_COLUMN = 512;
+/**
+ * Default artifact-on-disk cap for {@link OutputSink}.
+ *
+ * `0` means unbounded: by default, `artifact://<id>` references preserve the
+ * complete raw stream instead of a capped head/tail sample.
+ */
+export declare const ARTIFACT_DEFAULT_MAX_BYTES = 0;
+/** Default head budget; the remainder becomes the rolling tail window. */
+export declare const ARTIFACT_DEFAULT_HEAD_BYTES: number;
 export interface OutputSummary {
     output: string;
     truncated: boolean;
@@ -41,6 +50,20 @@ export interface OutputSinkOptions {
     onChunk?: (chunk: string) => void;
     /** Minimum ms between onChunk calls. 0 = every chunk (default). */
     chunkThrottleMs?: number;
+    /**
+     * Optional cap on bytes written to the artifact-on-disk file. When the cap
+     * is hit, the head window is preserved verbatim and subsequent output feeds
+     * a rolling tail window; on close, the sink writes a single
+     * `[ARTIFACT TRUNCATED: …]` notice between them. Default
+     * {@link ARTIFACT_DEFAULT_MAX_BYTES} (unbounded).
+     */
+    artifactMaxBytes?: number;
+    /**
+     * Bytes reserved for the head window of the capped artifact file. The
+     * tail window receives `artifactMaxBytes - artifactHeadBytes`. Default
+     * {@link ARTIFACT_DEFAULT_HEAD_BYTES}; clamped to `[0, artifactMaxBytes]`.
+     */
+    artifactHeadBytes?: number;
 }
 export interface TruncationResult {
     content: string;
@@ -136,6 +159,29 @@ export declare function formatMiddleElisionMarker(elidedLines: number, elidedByt
  * budget is empty or the content already fits.
  */
 export declare function truncateMiddle(content: string, options?: TruncationOptions): TruncationResult;
+/** Options for {@link enforceInlineByteCap}. */
+export interface InlineByteCapOptions {
+    /** Inline byte budget. Defaults to {@link DEFAULT_MAX_BYTES}. */
+    maxBytes?: number;
+    /** What the text is, for the elision marker (e.g. "bash output"). */
+    label: string;
+    /**
+     * Persist the full text as a session artifact. When an artifact id is
+     * returned, a `[raw output: artifact://<id>]` footer is appended so the
+     * elided bytes stay recoverable.
+     */
+    saveArtifact?: (full: string) => string | undefined | Promise<string | undefined>;
+}
+/**
+ * Final-defense inline size guard for tool results.
+ *
+ * No-op when `text` fits within `maxBytes` (the common path). Otherwise keeps
+ * ~60% of the budget from the head and ~25% from the tail — cut on line
+ * boundaries, never splitting a multi-byte UTF-8 sequence — with an elision
+ * marker between. The remaining ~15% is slack for the marker and the optional
+ * `[raw output: artifact://<id>]` footer, so the result stays under `maxBytes`.
+ */
+export declare function enforceInlineByteCap(text: string, options: InlineByteCapOptions): Promise<string>;
 export declare class TailBuffer {
     #private;
     readonly maxBytes: number;

package/dist/types/session/tool-choice-queue.d.ts

@@ -6,12 +6,12 @@ export interface ResolveInfo {
 export interface RejectInfo {
     /** The ToolChoice that was yielded but never (or unsuccessfully) served. */
     choice: ToolChoice;
-    reason: "aborted" | "error" | "cleared" | "removed";
+    reason: "aborted" | "error" | "cleared" | "removed" | "unavailable" | "not_invoked";
 }
 /** "requeue" replays the lost yield next turn; "drop" (or void/undefined) discards it. */
 export type RejectOutcome = "requeue" | "drop";
 export interface DirectiveCallbacks {
-    /** Fires when the yield was served (LLM call completed). The directive is consumed. */
+    /** Fires when the yield completed; onInvoked directives require the requested tool to run first. */
     onResolved?: (info: ResolveInfo) => void;
     /**
      * Fires when the yield is being discarded. Return "requeue" to replay the
@@ -52,9 +52,9 @@ export declare class ToolChoiceQueue {
      */
     nextToolChoice(): ToolChoice | undefined;
     /**
-     * The in-flight yield was served — the LLM call completed normally.
-     * Fires onResolved, then clears in-flight state. The directive's generator
-     * remains in the queue if it has more values to yield.
+     * The in-flight yield completed normally. Directives with onInvoked are only
+     * consumed after their requested tool ran; a normal text turn or a different
+     * tool call requeues/rejects the directive instead.
      */
     resolve(): void;
     /**
@@ -65,7 +65,7 @@ export declare class ToolChoiceQueue {
     reject(reason: RejectInfo["reason"]): void;
     /** True if there is an in-flight yield that hasn't been resolved or rejected. */
     get hasInFlight(): boolean;
-    /** Peek the in-flight directive's onInvoked handler, if any. */
+    /** Return the in-flight directive's onInvoked handler and mark it when called. */
     peekInFlightInvoker(): ((input: unknown) => Promise<unknown> | unknown) | undefined;
     /** Remove all directives with the given label. Rejects in-flight if it matches. */
     removeByLabel(label: string): void;

package/dist/types/session/yield-queue.d.ts

@@ -7,7 +7,7 @@ export interface YieldDispatcher<P> {
 }
 export interface YieldQueueOptions {
     isStreaming: () => boolean;
-    injectStreaming(msg: AgentMessage): void;
+    injectStreaming?(msg: AgentMessage): void;
     injectIdle(messages: AgentMessage[]): Promise<void>;
     scheduleIdleFlush(run: () => Promise<void>): void;
 }
@@ -19,6 +19,15 @@ export declare class YieldQueue {
     enqueue<P>(kind: string, entry: P): void;
     has(kind?: string): boolean;
     flush(mode: YieldFlushMode): Promise<void>;
+    /**
+     * Snapshot and remove all queued entries, returning one lazy thunk per kind.
+     * Each thunk applies the dispatcher's staleness filter and builds the batched
+     * message only when called — so the consumer (the agent loop) decides, at the
+     * moment it injects, whether the message is still worth delivering (a thunk may
+     * return null to skip). Background-job completions and late diagnostics reach
+     * the model between requests without the agent having to stop.
+     */
+    drainLazy(): Array<() => AgentMessage | null>;
     clear(): void;
 }
 export {};

package/dist/types/slash-commands/acp-builtins.d.ts

@@ -1,6 +1,22 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
 import type { AcpBuiltinSlashCommandResult, SlashCommandRuntime } from "./types";
 export type { AcpBuiltinSlashCommandResult } from "./types";
+/**
+ * All names (primary + aliases) that are reserved by ACP builtins. Used to
+ * filter out extension commands that would shadow a builtin or its alias at
+ * dispatch time (e.g. `models` is an alias for `/model`, so an extension
+ * registering `models` would appear in the palette but execute the builtin).
+ */
+export declare const ACP_BUILTIN_RESERVED_NAMES: ReadonlySet<string>;
+/**
+ * Whether an extension command named `name` would be captured by ACP builtin
+ * dispatch before reaching the extension handler. Beyond exact name/alias
+ * collisions, `parseSlashCommand` treats `:` as a name/args separator, so a
+ * colon-namespaced name whose prefix is a handled builtin (e.g. `model:foo`)
+ * executes the `/model` builtin with `foo` as args. Such names must not be
+ * advertised to ACP clients.
+ */
+export declare function isAcpBuiltinShadowedName(name: string): boolean;
 /**
  * Commands advertised to ACP clients. Entries without a text-mode `handle`
  * (e.g. `/quit`, `/login`, dashboards) are filtered out so the client doesn't

package/dist/types/slash-commands/available-commands.d.ts

@@ -0,0 +1,34 @@
+import type { AvailableCommand } from "@agentclientprotocol/sdk";
+import type { SkillsSettings } from "../config/settings";
+import type { LoadedCustomCommand } from "../extensibility/custom-commands";
+import type { ExtensionRunner } from "../extensibility/extensions";
+import { type Skill } from "../extensibility/skills";
+import { type FileSlashCommand } from "../extensibility/slash-commands";
+export type AvailableSlashCommandSource = "builtin" | "skill" | "extension" | "custom" | "mcp_prompt" | "file";
+export interface InternalAvailableSlashCommand {
+    name: string;
+    aliases?: string[];
+    description?: string;
+    input?: {
+        hint: string;
+    };
+    subcommands?: Array<{
+        name: string;
+        description?: string;
+        usage?: string;
+    }>;
+    source: AvailableSlashCommandSource;
+}
+export interface AvailableCommandsSession {
+    readonly extensionRunner?: ExtensionRunner;
+    readonly customCommands: ReadonlyArray<LoadedCustomCommand>;
+    readonly mcpPromptCommands?: ReadonlyArray<LoadedCustomCommand>;
+    readonly skills: ReadonlyArray<Skill>;
+    readonly skillsSettings?: SkillsSettings;
+    setSlashCommands(slashCommands: FileSlashCommand[]): void;
+    sessionManager: {
+        getCwd(): string;
+    };
+}
+export declare function buildAvailableSlashCommands(session: AvailableCommandsSession, loadFileCommands?: (cwd: string) => Promise<FileSlashCommand[]>): Promise<InternalAvailableSlashCommand[]>;
+export declare function toAcpAvailableCommands(commands: readonly InternalAvailableSlashCommand[]): AvailableCommand[];

package/dist/types/slash-commands/builtin-registry.d.ts

@@ -1,9 +1,19 @@
+import type { AutocompleteItem } from "@prometheus-ai/tui";
 import type { BuiltinSlashCommand, ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime } from "./types";
 export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+export declare const BUILTIN_SLASH_COMMAND_RESERVED_NAMES: ReadonlySet<string>;
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export declare const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand>;
+/**
+ * Materialized builtin slash commands with completion functions derived from
+ * declarative subcommand/hint definitions.
+ */
+export declare const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand & {
+    getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
+    getInlineHint?: (argumentText: string) => string | null;
+}>;
 /**
  * Unified registry exposed for cross-mode tooling. Each spec carries at least
  * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the

package/dist/types/slash-commands/helpers/active-oauth-account.d.ts

@@ -0,0 +1,14 @@
+import type { UsageLimit, UsageReport } from "@prometheus-ai/ai";
+import type { OAuthAccountIdentity } from "../../session/auth-storage";
+/**
+ * True when a single usage-limit column belongs to the given OAuth identity.
+ *
+ * Single definition of the matching rules for both `/usage` renderers:
+ * - `accountId` ↔ report metadata `accountId`/`account_id` or `limit.scope.accountId`
+ * - `email`     ↔ report metadata `email`
+ * - `projectId` ↔ report metadata `projectId` or `limit.scope.projectId`
+ *   (Google-style providers key usage on the GCP project, not an account id)
+ */
+export declare function limitMatchesActiveAccount(report: UsageReport, limit: UsageLimit, identity: OAuthAccountIdentity | undefined): boolean;
+/** True when any limit column in `report` belongs to the given OAuth identity. */
+export declare function reportMatchesActiveAccount(report: UsageReport, identity: OAuthAccountIdentity | undefined): boolean;

package/dist/types/slash-commands/helpers/logout.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthAccountIdentity, StoredAuthCredential } from "../../session/auth-storage";
+export interface LogoutAccount {
+    credentialId: number;
+    provider: string;
+    label: string;
+    detail: string;
+    type: "api_key" | "oauth";
+    active: boolean;
+}
+interface LogoutAccountOptions {
+    activeIdentity?: OAuthAccountIdentity;
+    activeApiKey?: boolean;
+}
+export declare function toLogoutAccounts(provider: string, credentials: StoredAuthCredential[], options?: LogoutAccountOptions): LogoutAccount[];
+export {};

package/dist/types/slash-commands/helpers/reset-usage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared helpers for the `/usage reset` command (TUI selector + ACP): turn the
+ * live per-account reset-credit status into selector rows, and map a redeem
+ * outcome code to a human message.
+ */
+import type { ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget } from "../../session/auth-storage";
+export declare const CODEX_PROVIDER_ID = "openai-codex";
+/** One Codex account row for the reset-usage selector. */
+export interface ResetUsageAccount {
+    /** Display label (email, else account id). */
+    label: string;
+    /** Saved resets redeemable for this account right now. */
+    availableCount: number;
+    /** Identifies the account when redeeming. */
+    target: ResetCreditTarget;
+    /** Whether this is the session's active Codex account. */
+    active: boolean;
+    /** Set when this account could not be reached (token/list failure). */
+    error?: string;
+}
+/**
+ * Map live per-account reset status to selector rows. Sorted with the active
+ * account first, then most-credits, then label.
+ */
+export declare function toResetUsageAccounts(statuses: ResetCreditAccountStatus[]): ResetUsageAccount[];
+/** Human-facing summary of a redeem outcome for status lines and ACP output. */
+export declare function describeRedeemOutcome(outcome: ResetCreditRedeemOutcome, label: string): string;

package/dist/types/slash-commands/helpers/stats-dashboard.d.ts

@@ -0,0 +1,13 @@
+export declare const DEFAULT_STATS_DASHBOARD_PORT = 3847;
+export interface StatsDashboardArgs {
+    port: number;
+}
+export interface StatsDashboardLaunchResult {
+    url: string;
+    message: string;
+}
+export declare function parseStatsDashboardArgs(args: string): StatsDashboardArgs | {
+    error: string;
+};
+export declare function launchStatsDashboard(args: StatsDashboardArgs): Promise<StatsDashboardLaunchResult>;
+export declare function stopStatsDashboard(): void;

package/dist/types/slash-commands/types.d.ts

@@ -12,6 +12,7 @@ export interface SubcommandDef {
 /** Declarative builtin slash command metadata used by autocomplete and help UI. */
 export interface BuiltinSlashCommand {
     name: string;
+    aliases?: string[];
     description: string;
     /** Subcommands for dropdown completion (e.g. /mcp add, /mcp list). */
     subcommands?: SubcommandDef[];
@@ -69,19 +70,16 @@ export interface SlashCommandRuntime {
 }
 /**
  * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
- * mode context plus the background-detach hook. Intentionally narrower than
- * `SlashCommandRuntime` so existing callers can keep building it from just
- * `{ ctx, handleBackgroundCommand }`; when the TUI dispatcher needs to invoke
- * a `handle` (no `handleTui` override), it synthesizes a `SlashCommandRuntime`
- * from `ctx`.
+ * mode context. Intentionally narrower than `SlashCommandRuntime` so existing
+ * callers can keep building it from just `{ ctx }`; when the TUI dispatcher
+ * needs to invoke a `handle` (no `handleTui` override), it synthesizes a
+ * `SlashCommandRuntime` from `ctx`.
  */
 export interface TuiSlashCommandRuntime {
     ctx: InteractiveModeContext;
-    handleBackgroundCommand: () => void;
 }
 /** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
 export interface SlashCommandSpec extends BuiltinSlashCommand {
-    aliases?: string[];
     /** When false, the dispatcher refuses to handle invocations that include arguments. */
     allowArgs?: boolean;
     /**
@@ -98,8 +96,6 @@ export interface SlashCommandSpec extends BuiltinSlashCommand {
      * not silently drop it from `available_commands_update`.
      */
     acpInputHint?: string;
-    /** When false, text-mode callers may execute the command but ACP does not advertise it in `available_commands_update`. */
-    advertiseInAcp?: boolean;
     /**
      * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
      * and, via the TUI adapter, when no `handleTui` override is provided.

package/dist/types/ssh/connection-manager.d.ts

@@ -22,6 +22,14 @@ interface SSHArgsOptions {
 }
 export declare function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined>;
 export declare function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined>;
+/**
+ * Synchronous, probe-free host info lookup for startup paths.
+ *
+ * Checks the in-memory cache, then falls back to a synchronous read of the
+ * persisted host-info cache file. Never opens a connection or probes the
+ * remote host — callers get `undefined` when nothing is cached yet.
+ */
+export declare function getCachedHostInfoSync(host: SSHConnectionTarget): SSHHostInfo | undefined;
 export declare function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo>;
 export declare function buildRemoteCommand(host: SSHConnectionTarget, command: string, options?: SSHArgsOptions): Promise<string[]>;
 export declare function ensureConnection(host: SSHConnectionTarget): Promise<void>;