jeopi-cli 16.2.14 → 16.2.15

package/dist/types/session/unexpected-stop-classifier.d.ts

@@ -0,0 +1,13 @@
+import { type AssistantMessage } from "jeopi-ai";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+export interface ClassifyUnexpectedStopDeps {
+    settings: Settings;
+    registry: ModelRegistry;
+    sessionId: string;
+    metadataResolver?: (provider: string) => Record<string, unknown> | undefined;
+    signal?: AbortSignal;
+}
+export declare function isUnexpectedStopCandidate(message: AssistantMessage): boolean;
+export declare function classifyUnexpectedStop(text: string, deps: ClassifyUnexpectedStopDeps): Promise<boolean | undefined>;
+export declare function parseUnexpectedStopClassification(text: string): boolean | undefined;

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

@@ -0,0 +1,37 @@
+import type { AgentMessage } from "jeopi-agent-core";
+export interface YieldDispatcher<P> {
+    /** Drop entries already delivered through another path. Called per-entry at flush time. */
+    isStale?(entry: P): boolean;
+    /** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
+    build(survivors: P[]): AgentMessage | null;
+    /** If true, entries for this kind are drained only by {@link drainLazy} and never trigger the idle flush. */
+    skipIdleFlush?: boolean;
+}
+export interface YieldQueueOptions {
+    isStreaming: () => boolean;
+    injectStreaming?(msg: AgentMessage): void;
+    injectIdle(messages: AgentMessage[]): Promise<void>;
+    scheduleIdleFlush(run: () => Promise<void>): void;
+}
+type YieldFlushMode = "streaming" | "idle";
+export declare class YieldQueue {
+    #private;
+    constructor(options: YieldQueueOptions);
+    register<P>(kind: string, dispatcher: YieldDispatcher<P>): () => void;
+    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>;
+    /** Drop queued entries. With `kind`, drop only that kind's entries (leaving
+     *  any pending idle-flush for other kinds intact); otherwise drop everything. */
+    clear(kind?: string): void;
+}
+export {};

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

@@ -0,0 +1,34 @@
+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
+ * see commands it cannot drive.
+ */
+export declare const ACP_BUILTIN_SLASH_COMMANDS: AvailableCommand[];
+/**
+ * Dispatch a slash command in ACP/text mode. Returns:
+ * - `false` when no builtin matched (or matched a TUI-only entry); the caller
+ *   should forward the input as a prompt.
+ * - `{ consumed: true }` when the command handled the input entirely.
+ * - `{ prompt }` when the command was handled but a residual prompt should be
+ *   sent to the model.
+ */
+export declare function executeAcpBuiltinSlashCommand(text: string, runtime: SlashCommandRuntime): Promise<AcpBuiltinSlashCommandResult>;

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

@@ -0,0 +1,36 @@
+import { type AutocompleteItem } from "jeopi-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 interface TuiBuiltinSlashCommand extends BuiltinSlashCommand {
+    getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null | Promise<AutocompleteItem[] | null>;
+    getInlineHint?: (argumentText: string) => string | null;
+    getAutocompleteDescription?: () => string | undefined;
+}
+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<TuiBuiltinSlashCommand>;
+export declare function buildTuiBuiltinSlashCommands(runtime: TuiSlashCommandRuntime): ReadonlyArray<TuiBuiltinSlashCommand>;
+/**
+ * Unified registry exposed for cross-mode tooling. Each spec carries at least
+ * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the
+ * ACP dispatcher requires `handle` and skips TUI-only entries.
+ */
+export declare const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommandSpec>;
+/**
+ * Execute a builtin slash command in the interactive TUI.
+ *
+ * Returns `false` when no builtin matched. Returns `true` when a command
+ * consumed the input entirely. Returns a `string` when the command was handled
+ * but remaining text should be sent as a prompt.
+ */
+export declare function executeBuiltinSlashCommand(text: string, runtime: BuiltinSlashCommandRuntime): Promise<string | boolean>;
+/** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
+export declare function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined;
+export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };

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

@@ -0,0 +1,14 @@
+import type { UsageLimit, UsageReport } from "jeopi-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/collab-qrcode.d.ts

@@ -0,0 +1,13 @@
+import { type Component } from "jeopi-tui";
+/**
+ * One-shot transcript block that prints a collab browser-join URL as a
+ * scannable QR code. The symbol is encoded once at construction (byte mode,
+ * EC level M) and rendered as ANSI half-blocks; on terminals too narrow for
+ * the symbol it degrades to a one-line hint pointing at the printed URL.
+ */
+export declare class CollabQrCodeComponent implements Component {
+    #private;
+    readonly url: string;
+    constructor(url: string);
+    render(width: number): readonly string[];
+}

package/dist/types/slash-commands/helpers/context-report.d.ts

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/context` ACP-mode text. Tries the rich breakdown first
+ * (categories + auto-compact buffer + free slack) and falls back to the
+ * minimal "window/used" lines when the breakdown helper throws.
+ */
+export declare function buildContextReportText(runtime: SlashCommandRuntime): string;

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

@@ -0,0 +1,10 @@
+import { type Theme } from "../../modes/theme/theme";
+/** Format a millisecond duration as a coarse-grained human label. */
+export declare function formatDuration(ms: number): string;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
+/**
+ * Render an ASCII progress bar with a trailing percent label.
+ * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
+ */
+export declare function renderAsciiBar(fraction: number | undefined, width?: number, uiTheme?: ProgressBarTheme): string;
+export {};

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/marketplace-manager.d.ts

@@ -0,0 +1,8 @@
+import { MarketplaceManager } from "../../extensibility/plugins/marketplace";
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build a `MarketplaceManager` wired up with the active project's registry
+ * paths and the shared plugin-root cache invalidator. Reused by both `/plugins`
+ * and `/marketplace` handlers so cache invalidation stays consistent.
+ */
+export declare function createMarketplaceManager(runtime: SlashCommandRuntime): Promise<MarketplaceManager>;

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

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/mcp` handler. Shared by both dispatchers via the spec. */
+export declare function handleMcpAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

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

@@ -0,0 +1,33 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+export interface ParsedSubcommand {
+    verb: string;
+    rest: string;
+}
+export type ConfigScope = "user" | "project";
+export interface NamedScopeArgs {
+    name?: string;
+    scope: ConfigScope;
+    error?: string;
+}
+/**
+ * Parse a slash-invocation string into `name`/`args`.
+ *
+ * The separator is the earliest whitespace or `:` character so that both
+ * `/foo bar` and `/foo:bar` map to `{ name: "foo", args: "bar" }`.
+ */
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+/** Mark a command as fully consumed in the ACP shape. */
+export declare function commandConsumed(): {
+    consumed: true;
+};
+/** Emit a usage/error message and consume the command. */
+export declare function usage(text: string, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;
+/** Split `<verb> <rest>` on the first whitespace; lowercases `verb`. */
+export declare function parseSubcommand(input: string): ParsedSubcommand;
+export declare function errorMessage(error: unknown): string;
+/**
+ * Parse `<name?> [--scope project|user]`-style argument strings used by
+ * remove/rm-style subcommands. `name` is optional so callers can surface
+ * "name required" diagnostics with their own messaging.
+ */
+export declare function parseNamedScopeArgs(rest: string, invalidScopeMessage: string): NamedScopeArgs;

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/ssh.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/ssh` handler. Shared by both dispatchers via the spec. */
+export declare function handleSshAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

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

@@ -0,0 +1,3 @@
+import type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime } from "../types";
+/** ACP/text-mode `/todo` handler. Shared by both dispatchers via the spec. */
+export declare function handleTodoAcp(command: ParsedSlashCommand, runtime: SlashCommandRuntime): Promise<SlashCommandResult>;

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

@@ -0,0 +1,7 @@
+import type { SlashCommandRuntime } from "../types";
+/**
+ * Build the `/usage` ACP-mode text. Prefers provider-reported limits when the
+ * session exposes `fetchUsageReports`; otherwise falls back to the local
+ * session-manager tallies.
+ */
+export declare function buildUsageReportText(runtime: SlashCommandRuntime): Promise<string>;

package/dist/types/slash-commands/marketplace-install-parser.d.ts

@@ -0,0 +1,33 @@
+export interface MarketplaceInstallArgs {
+    force: boolean;
+    scope: "user" | "project";
+    installSpec: string;
+}
+/**
+ * Parse the argument string following `/marketplace install`.
+ *
+ * Returns either the parsed args or an `{ error }` object whose message is
+ * suitable for direct display to the user via `ctx.showStatus`.
+ *
+ * Accepted flags (any order):
+ *   --force                 Force-reinstall even if already installed
+ *   --scope user|project    Installation scope (default: user)
+ *
+ * Exactly one positional argument is required: `name@marketplace`.
+ */
+export declare function parseMarketplaceInstallArgs(rest: string): MarketplaceInstallArgs | {
+    error: string;
+};
+export interface PluginScopeArgs {
+    pluginId: string;
+    scope?: "user" | "project";
+}
+/**
+ * Parse `[--scope user|project] <name@marketplace>` for commands that accept a
+ * single plugin ID and an optional scope flag.
+ *
+ * Returns parsed args or `{ error }` ready for `ctx.showStatus`.
+ */
+export declare function parsePluginScopeArgs(rest: string, usageHint: string): PluginScopeArgs | {
+    error: string;
+};

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

@@ -0,0 +1,127 @@
+import type { Settings } from "../config/settings";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession } from "../session/agent-session";
+import type { SessionManager } from "../session/session-manager";
+/** Declarative subcommand definition for commands like /mcp. */
+export interface SubcommandDef {
+    name: string;
+    description: string;
+    /** Usage hint shown as dim ghost text, e.g. "<name> [--scope project|user]". */
+    usage?: string;
+}
+/** 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[];
+    /** Static inline hint when command takes a simple argument (no subcommands). */
+    inlineHint?: string;
+    /** TUI-only dynamic status text for command-name autocomplete. Static `description` remains canonical for ACP/help. */
+    getTuiAutocompleteDescription?: (runtime: TuiSlashCommandRuntime) => string | undefined;
+}
+/** Parsed slash-command text after stripping the leading "/". */
+export interface ParsedSlashCommand {
+    name: string;
+    args: string;
+    text: string;
+}
+/**
+ * Result returned by a slash-command handler.
+ *
+ * - `undefined` (and the implicit `void` return) — command was handled and
+ *   consumed; no further input. Handlers may simply omit a `return` rather than
+ *   building `{ consumed: true }`; `void` is accepted in the handler signatures
+ *   below so the contract typechecks under TypeScript 5.x (which does not
+ *   coerce `() => void` to `() => T | undefined`) as well as 6.x / tsgo.
+ * - `{ consumed: true }` — explicit equivalent of the above (ACP shape).
+ * - `{ prompt: string }` — command handled, pass `prompt` through as the new
+ *   user input (e.g. `/force <tool> <prompt>` keeps `<prompt>` as the message).
+ */
+export type SlashCommandResult = undefined | {
+    consumed: true;
+} | {
+    prompt: string;
+};
+/**
+ * Runtime visible to slash-command handlers that run in text/ACP mode.
+ *
+ * Both the TUI dispatcher (when invoking a `handle` via its adapter) and the
+ * ACP dispatcher pass this shape. Implementations MUST NOT depend on TUI-only
+ * state (editor, selectors, status line).
+ */
+export interface SlashCommandRuntime {
+    session: AgentSession;
+    sessionManager: SessionManager;
+    settings: Settings;
+    cwd: string;
+    /** Emit text to the operator. TUI maps to `ctx.showStatus`, ACP to `sessionUpdate`. */
+    output: (text: string) => Promise<void> | void;
+    /** Re-advertise the available command list (no-op outside ACP). */
+    refreshCommands: () => Promise<void> | void;
+    /**
+     * Reload plugin state (caches, slash command registry, project registries)
+     * and re-emit available commands. Used by `/reload-plugins`, `/move`, and
+     * `/marketplace`/`/plugins` mutations so the session sees a consistent view
+     * after plugin or project-scope changes.
+     */
+    reloadPlugins: () => Promise<void>;
+    notifyTitleChanged?: () => Promise<void> | void;
+    notifyConfigChanged?: () => Promise<void> | void;
+}
+/**
+ * Runtime visible to TUI-only handlers (`handleTui`). Carries the interactive
+ * 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;
+}
+/** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
+export interface SlashCommandSpec extends BuiltinSlashCommand {
+    /** When false, the dispatcher refuses to handle invocations that include arguments. */
+    allowArgs?: boolean;
+    /**
+     * ACP-specific override for `description`. Used by `ACP_BUILTIN_SLASH_COMMANDS`
+     * when building `available_commands_update` payloads so the client receives
+     * mode-appropriate copy (e.g. `/dump` advertises "Return full transcript as
+     * plain text" in ACP rather than the TUI's clipboard-centric copy).
+     */
+    acpDescription?: string;
+    /**
+     * ACP-specific override for the advertised input hint. `subcommands`-only
+     * specs that historically advertised `<subcommand>` / `[on|off|status]` /
+     * `info|delete` to ACP clients carry the hint here so the unification does
+     * not silently drop it from `available_commands_update`.
+     */
+    acpInputHint?: string;
+    /**
+     * Text/ACP-mode handler. The same body is invoked from the ACP dispatcher
+     * and, via the TUI adapter, when no `handleTui` override is provided.
+     *
+     * Expressed as a union of two function types — one returning a
+     * `SlashCommandResult`, one returning `void` — so handlers that simply
+     * `return` (or omit the return) typecheck under TypeScript 5.x as well as
+     * 6.x / tsgo. TS 5.x does not coerce a `() => void` value into a
+     * `() => T | undefined` slot, so the two return shapes must be siblings
+     * rather than a `T | void` union inside one function type (which Biome's
+     * `noConfusingVoidType` also rejects).
+     */
+    handle?: ((command: ParsedSlashCommand, runtime: SlashCommandRuntime) => SlashCommandResult | Promise<SlashCommandResult>) | ((command: ParsedSlashCommand, runtime: SlashCommandRuntime) => void | Promise<void>);
+    /**
+     * TUI-only handler that supersedes `handle` when both are present. Use for
+     * selectors, wizards, dashboards, and anything else that requires
+     * `InteractiveModeContext`. See `handle` for the rationale behind the
+     * function-type union shape.
+     */
+    handleTui?: ((command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => SlashCommandResult | Promise<SlashCommandResult>) | ((command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime) => void | Promise<void>);
+}
+/** Result returned by `executeAcpBuiltinSlashCommand`. */
+export type AcpBuiltinSlashCommandResult = false | {
+    consumed: true;
+} | {
+    prompt: string;
+};

package/dist/types/ssh/__tests__/connection-manager-args.test.d.ts

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

package/dist/types/ssh/__tests__/file-transfer-posix-guard.test.d.ts

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

package/dist/types/ssh/config-writer.d.ts

@@ -0,0 +1,49 @@
+export interface SSHHostConfig {
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    description?: string;
+    compat?: boolean;
+}
+export interface SSHConfigFile {
+    hosts?: Record<string, SSHHostConfig>;
+}
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export declare function readSSHConfigFile(filePath: string): Promise<SSHConfigFile>;
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export declare function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void>;
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export declare function validateHostName(name: string): string | undefined;
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export declare function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export declare function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void>;
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export declare function removeSSHHost(filePath: string, name: string): Promise<void>;
+/**
+ * List all host names in a config file.
+ */
+export declare function listSSHHosts(filePath: string): Promise<string[]>;

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

@@ -0,0 +1,90 @@
+export interface SSHConnectionTarget {
+    name: string;
+    host: string;
+    username?: string;
+    port?: number;
+    keyPath?: string;
+    compat?: boolean;
+}
+export type SSHHostOs = "windows" | "linux" | "macos" | "unknown";
+export type SSHHostShell = "cmd" | "powershell" | "bash" | "zsh" | "sh" | "unknown";
+export type SshPlatform = typeof process.platform;
+export declare function supportsSshControlMaster(platform?: SshPlatform): boolean;
+export interface SSHHostInfo {
+    version: number;
+    os: SSHHostOs;
+    shell: SSHHostShell;
+    /**
+     * Shell name OMP verified can execute the POSIX transfer snippets
+     * (`head`/`cat`/`mv`/`test`/`ls`) `ssh://` uses. Probed by running
+     * `sh -lc` / `bash -lc` / `zsh -lc` against the remote and keeping the
+     * first one that round-trips a known marker. Independent of `shell`
+     * (the self-reported login shell), which may be noisy, exotic, or simply
+     * mis-classified — only `transferShell` gates ssh:// transfers.
+     */
+    transferShell?: "sh" | "bash" | "zsh";
+    compatShell?: "bash" | "sh";
+    compatEnabled: boolean;
+}
+interface SSHArgsOptions {
+    platform?: SshPlatform;
+    /** When true, omit `-n` so the remote command can read from our piped stdin. */
+    allowStdin?: boolean;
+}
+/**
+ * Parse a raw cache-file value (or any unknown) into a normalized
+ * {@link SSHHostInfo}, dropping fields that don't pass the per-field guards.
+ * Exported so cache-layer round-tripping (incl. the new `transferShell`
+ * field, #3719) is testable without touching disk.
+ */
+export declare function parseHostInfo(value: unknown): SSHHostInfo | null;
+/**
+ * Frame marker emitted by the remote OS/shell probe. The probe wraps its
+ * payload in this prefix so the parser can ignore startup-file noise (banners,
+ * `motd`, login messages, `Last login: …`) instead of trusting only the first
+ * line of stdout. See #3719.
+ */
+export declare const HOST_PROBE_MARKER = "PI_HOST_PROBE=";
+/** Marker for the transfer-shell capability probe. */
+export declare const TRANSFER_PROBE_MARKER = "PI_TRANSFER_OK|";
+/**
+ * Find the first line of `stdout`/`stderr` that begins with `marker` and
+ * return everything after it. Used by the SSH host probe so noisy login
+ * dotfiles can't corrupt OS/shell classification by emitting text on the
+ * first line of `ssh` output.
+ *
+ * Returns `null` when no marker line is found in either stream.
+ */
+export declare function extractProbePayload(stdout: string, stderr: string, marker?: string): string | null;
+/**
+ * Find `marker` anywhere in `stdout` or `stderr` and return everything that
+ * follows it, scanning stdout first. Returns `null` when the marker is in
+ * neither stream.
+ *
+ * Used by the transfer-shell capability probe. Some remotes have broken
+ * login dotfiles that swap fd 1/2, so the marker can land on stderr even
+ * though the probe ran the printf successfully (matches the host-info
+ * probe's stderr fallback). See #3719.
+ */
+export declare function findProbeMarker(stdout: string, stderr: string, marker: string): string | null;
+/** Classify a POSIX-ish `uname -s` payload from the transfer-shell probe. */
+export declare function osFromUname(value: string): SSHHostOs | undefined;
+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>;
+export declare function invalidateHostMetadata(hostNames: Iterable<string>): Promise<void>;
+export declare function closeConnection(hostName: string): Promise<void>;
+export declare function closeAllConnections(): Promise<void>;
+export declare function getControlPathTemplate(): string;
+export declare function getControlDir(): string;
+export {};