jeopi-cli 16.2.14 → 16.2.17

package/dist/types/cli/auth-gateway-cli.d.ts

@@ -0,0 +1,26 @@
+export type AuthGatewayAction = "serve" | "token" | "status" | "check";
+export interface AuthGatewayCommandArgs {
+    action: AuthGatewayAction;
+    flags: {
+        json?: boolean;
+        bind?: string;
+        regenerate?: boolean;
+        /**
+         * Disable bearer-token auth on inbound requests. Useful when the gateway
+         * is bound to loopback (the default `127.0.0.1:4000`) and you don't want
+         * to wire token-paste plumbing into every local client.
+         */
+        noAuth?: boolean;
+        /**
+         * Strict mode for `check` — additionally exercise every credential
+         * against its provider's chat-completion endpoint. The usage probe (run
+         * unconditionally) can pass while the chat endpoint still 401s the same
+         * bearer, so strict mode is the definitive "is this credential
+         * actually usable" signal. Slower and consumes a tiny amount of quota.
+         */
+        strict?: boolean;
+    };
+}
+declare const ACTIONS: readonly AuthGatewayAction[];
+export declare function runAuthGatewayCommand(cmd: AuthGatewayCommandArgs): Promise<void>;
+export { ACTIONS as AUTH_GATEWAY_ACTIONS };

package/dist/types/cli/bench-cli.d.ts

@@ -0,0 +1,85 @@
+import type { ResolvedThinkingLevel } from "jeopi-agent-core";
+import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, ServiceTierByFamily, SimpleStreamOptions } from "jeopi-ai";
+import type { ApiKeyResolverModel } from "../config/api-key-resolver";
+import { Settings } from "../config/settings";
+export interface BenchCommandArgs {
+    models: string[];
+    flags: {
+        runs?: number;
+        maxTokens?: number;
+        prompt?: string;
+        /** Service-tier setting value (`none` omits); overrides the configured `serviceTier` setting. */
+        serviceTier?: string;
+        json?: boolean;
+        par?: number;
+    };
+}
+export interface BenchModelRegistry {
+    getAll(): Model<Api>[];
+    getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
+    resolver(model: ApiKeyResolverModel, sessionId?: string): ApiKeyResolver;
+    hasConfiguredAuth?(model: Model<Api>): boolean;
+}
+export interface BenchRuntime {
+    modelRegistry: BenchModelRegistry;
+    settings?: Settings;
+    close?: () => void;
+}
+export interface BenchRunSuccess {
+    ok: true;
+    ttftMs: number;
+    durationMs: number;
+    outputTokens: number;
+    /** Generation throughput measured over the post-first-token window. */
+    tokensPerSecond: number;
+}
+export interface BenchRunFailure {
+    ok: false;
+    error: string;
+}
+export type BenchRunResult = BenchRunSuccess | BenchRunFailure;
+export interface BenchAverages {
+    ttftMs: number;
+    durationMs: number;
+    outputTokens: number;
+    tokensPerSecond: number;
+}
+export interface BenchModelReport {
+    /** Selector as the user typed it (e.g. "opus" or "gemini-3.5:low"). */
+    selector: string;
+    /** Resolved `provider/id`. */
+    model: string;
+    /** Explicit thinking level from a `:level` selector suffix; undefined = provider default. */
+    thinking?: ResolvedThinkingLevel;
+    results: BenchRunResult[];
+    /** Averages over successful runs; null when every run failed. */
+    average: BenchAverages | null;
+}
+export interface BenchSummary {
+    runs: number;
+    maxTokens: number;
+    models: BenchModelReport[];
+    failures: number;
+    /** Requested per-family service tiers, resolved per model before reaching the wire. */
+    serviceTierByFamily?: ServiceTierByFamily;
+}
+type BenchStreamSimple = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+export interface BenchDependencies {
+    createRuntime?: () => Promise<BenchRuntime>;
+    randomSessionId?: () => string;
+    writeStdout?: (text: string) => void;
+    writeStderr?: (text: string) => void;
+    setExitCode?: (code: number) => void;
+    streamSimple?: BenchStreamSimple;
+    now?: () => number;
+    stdoutIsTTY?: boolean;
+}
+/**
+ * Tokens/s over the generation window (duration minus TTFT) so queue/prefill
+ * latency does not dilute throughput. Falls back to total duration when the
+ * response arrived as a single chunk (TTFT ~ duration).
+ */
+export declare function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number, deltaChunkCount: number): number;
+export declare function formatBenchTable(summary: BenchSummary): string;
+export declare function runBenchCommand(command: BenchCommandArgs, deps?: BenchDependencies): Promise<BenchSummary>;
+export {};

package/dist/types/cli/classify-install-target.d.ts

@@ -0,0 +1,12 @@
+export type ClassifiedInstallTarget = {
+    type: "local";
+    path: string;
+} | {
+    type: "marketplace";
+    name: string;
+    marketplace: string;
+} | {
+    type: "npm";
+    spec: string;
+};
+export declare function classifyInstallTarget(spec: string, knownMarketplaces: Set<string>): ClassifiedInstallTarget;

package/dist/types/cli/claude-trace-cli.d.ts

@@ -0,0 +1,54 @@
+export declare const CLAUDE_TRACE_DEBUG_CERT = "-----BEGIN CERTIFICATE-----\nMIIDFzCCAf+gAwIBAgIUAe9omAqLbydZc5ZYZGhwbbpMSF0wDQYJKoZIhvcNAQEL\nBQAwGzEZMBcGA1UEAwwQb21wLWNsYXVkZS10cmFjZTAeFw0yNjA2MDIwODA2MjFa\nFw0zNjA1MzAwODA2MjFaMBsxGTAXBgNVBAMMEG9tcC1jbGF1ZGUtdHJhY2UwggEi\nMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCmpGe5T8B0oA2L82Rn5JJdXOBS\nZX0DyBjiIK+Tqe8T3oAr41XDLnweqtrMDSBDYbVqAoKjNbaTUSYYcxSm0MAVs63w\n08SfJmShZM9pElfANqXqMiyhksFgji7JEyt/rbbId207a7s5KvRvm3g/sxN/wGtr\nC5LCLMlc2GWEGD8qrVIQbmLw884qvtXi70RFUPP3Wpy4wGMWSdE+9IA27R5cMJS5\noHsO4HGB6J8VzLY+HGY2yr4BJ9qrAyjd1UetFd9RdcjyWpsbAfX8nWP+uleTNOiT\nExNz7dPt/k6OPLNmI1iT/ruRS0uUzHZTimPd67TPQR/70RaW7Bh5wArawGw9AgMB\nAAGjUzBRMB0GA1UdDgQWBBQa4Ir8P3GAolZoPiuB4V2cq3riAjAfBgNVHSMEGDAW\ngBQa4Ir8P3GAolZoPiuB4V2cq3riAjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3\nDQEBCwUAA4IBAQClPYki235gDEUu7eDm60qsAGWxbKVv4pSh+vB+xgNgzMk4aOuU\nmSfp8Y8covwklph8VfDoKTaEGqqX0Q5s74Ctl6Mwy7b0u8Zztk/g4GynLocI7TQD\nftZMgZka49+FkEsjp+XZtQbO4vOL5UsccpsLhFQQQuhVyiJ4gNo/VzgvSDkBuf3Q\nRz7xFiDKCqFEoMPty4+nKEw5832FJ5mDCOyMk6fGSO8Wbt/hmRQQFu2cSdoBs0OT\nAQQJETQjPkKeTDX4jdSAlOeKwfyjfdfgeQuMkzX8xafisJa66MLPzOVbIuGbvbWD\nQVCd76iYPcfNK+JZUhmAUvTHSuwgJMZ6+NgI\n-----END CERTIFICATE-----";
+export declare const CLAUDE_TRACE_DEBUG_KEY = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCmpGe5T8B0oA2L\n82Rn5JJdXOBSZX0DyBjiIK+Tqe8T3oAr41XDLnweqtrMDSBDYbVqAoKjNbaTUSYY\ncxSm0MAVs63w08SfJmShZM9pElfANqXqMiyhksFgji7JEyt/rbbId207a7s5KvRv\nm3g/sxN/wGtrC5LCLMlc2GWEGD8qrVIQbmLw884qvtXi70RFUPP3Wpy4wGMWSdE+\n9IA27R5cMJS5oHsO4HGB6J8VzLY+HGY2yr4BJ9qrAyjd1UetFd9RdcjyWpsbAfX8\nnWP+uleTNOiTExNz7dPt/k6OPLNmI1iT/ruRS0uUzHZTimPd67TPQR/70RaW7Bh5\nwArawGw9AgMBAAECggEADX2mhA3H0pPuj35J36X/5Me9xWM//AwOr6febwGalazg\nCtg3EOZ01/VptzaiKQetAdhoLmxidooNn9HD7JQJKPid7q7w7m1+R26mN/xrLD2A\nWyBqv+iQoo+ANs5y1BMChuIxmVY/FwFk6UWDNlekuXqgzPln4okbrYTmBbaszniO\nMu1SI/3fpnTA3iJ634FUSRVoUPP8r0WEEUtpW1wAhsJR701gvKRYw/+YcRglkhm7\nT4l6TuBcgIVzUqAc3oZLHVIMKN0ZprZSeopSRozTcUANfYONakvK9Hx1qf+/rmTR\nqZHg2uOxlqvxyABnwdk8rmyFx8YqUeN9jaAbbXxtBQKBgQDQRjc0gVg4STqcFqUu\nFW35MZ88S7+xTuRd/EG1dpsu2lptx1yhSLTsF5GfxBQKXCQUfWrpkyuCmlV6s+wJ\nH0LSyAJQ4ffBsFterQz7dRKTlhRJNk5PYn8jjNCAuBYVSbQZqZ3yZgG3CT3G5+PZ\n8Ln3tJHqTRfP5B8KTMcNYiLI0wKBgQDM0/gdb9Dvdz/32GIpxwNNIb52IxnNVVrm\nM69+4XNg6CqvctZFuaMQ03W2J5IKAdESaCGLz9pwHZRjfBORcw3BPKD2QkfN5NJg\nhWvLlfAsblCYiCCjTCB6rf1OJOQ5fHoNFh1wqDaQCk0flsb9nlZmQQR5ZUHaJhSC\nQqMmeKvMrwKBgQDDzp+sH0Z/dGlDwg59auw/caWRHG4WFmOg8L4eCmoO/H4z41B0\n2VQu+mGQYNmue733/Yl8Gz62xL5EY88vLFK4tA1pWWiCknj0Y6Fm70QNuPVNd17c\nR2/cTlDgEzG/xdEqp0q1T62hFXEdBXoztZxBA2SDcQNIEeIU3uXs8SxevQKBgFp4\nacf+wody4aNERR900sV32RtvJ49lWxAA1kwxone0NF5oV7JWa2scK4r4cW3QHZuG\nuQJ7HV2WAxvqCu6cpf+rGuGKpxKPNkkBxXoX0Qye8SReRCQ8lL/7J74jV1b43yP2\nl6xR8D+w/R2tyFjvXfQuVZ6VFgAX/8kFS/DLLf7rAoGAcnFgCwyzcq6FWL8iW23J\nGnbZ0IQk6SPch87MzMmnOFlEXrCf5l832vwI65tNzOoB0yQoWVfBv5sb4Zy9zeFj\nFbkpRZC0Kfi9PLzDV4IawoIINYthOJxIKJg+yrmrUWCggXxwdzYIYKLRIskMXoYs\nmNMXfUstElEcKO7+DKiPi6U=\n-----END PRIVATE KEY-----";
+export interface HeaderEntry {
+    name: string;
+    value: string;
+}
+export interface CapturedRequest {
+    method: string;
+    path: string;
+    version: string;
+    headers: HeaderEntry[];
+    body: string;
+}
+export interface CapturedResponse {
+    statusCode: number | undefined;
+    statusMessage: string;
+    version: string;
+    headers: HeaderEntry[];
+    body: string;
+}
+export interface CapturedMessagesExchange {
+    target: string;
+    request: CapturedRequest;
+    response: CapturedResponse;
+}
+export interface ClaudeMessagesProxyOptions {
+    host?: string;
+    port?: number;
+    upstreamTlsRejectUnauthorized?: boolean;
+}
+export interface ClaudeTraceCommandArgs {
+    command?: string;
+    message?: string;
+    cwd?: string;
+    host?: string;
+    port?: number;
+    timeoutMs?: number;
+    inputDelayMs?: number;
+    json?: boolean;
+    upstreamTlsRejectUnauthorized?: boolean;
+}
+export declare function formatCapturedMessagesExchange(exchange: CapturedMessagesExchange): string;
+export declare class ClaudeMessagesProxy {
+    #private;
+    constructor(options?: ClaudeMessagesProxyOptions);
+    get host(): string;
+    get port(): number;
+    get url(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    waitForCapture(timeoutMs: number): Promise<CapturedMessagesExchange>;
+}
+export declare function runClaudeMessagesCapture(args?: ClaudeTraceCommandArgs): Promise<CapturedMessagesExchange>;
+export declare function runClaudeTraceCommand(args?: ClaudeTraceCommandArgs): Promise<void>;

package/dist/types/cli/commands/init-xdg.d.ts

@@ -0,0 +1 @@
+export declare function initXdg(): Promise<void>;

package/dist/types/cli/commands/migrate-legacy.d.ts

@@ -0,0 +1 @@
+export declare function migrateLegacyConfig(): Promise<void>;

package/dist/types/cli/completion-gen.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Shell-completion generation (bash, zsh, fish).
+ *
+ * Single source of truth: the declarative `flags`/`args` descriptors carried by
+ * each `Command` subclass plus the registered subcommand table. {@link buildSpec}
+ * walks that metadata — the same data `renderCommandBody` renders for `--help` —
+ * and {@link generateCompletion} emits a self-contained completion script. Adding
+ * a flag to a command's static `flags` therefore propagates into completions with
+ * no edits here.
+ *
+ * Static candidates (enum `options`, the builtin tool list) are baked into the
+ * script. A small set of flags resolve dynamic candidates (the live model
+ * catalog and on-disk sessions) by calling back into `<bin> __complete <kind>`
+ * — see `commands/complete.ts`. The flag→source mapping below is the only manual
+ * knob and is keyed by flag name so it stays stable as flags are added.
+ */
+import type { CliConfig } from "jeopi-utils/cli";
+export type Shell = "bash" | "zsh" | "fish";
+/** How a flag/positional value should be completed. */
+export type ValueSource = {
+    kind: "flag";
+} | {
+    kind: "value";
+} | {
+    kind: "enum";
+    values: readonly string[];
+} | {
+    kind: "list";
+    values: readonly string[];
+} | {
+    kind: "models";
+    multiple: boolean;
+} | {
+    kind: "sessions";
+} | {
+    kind: "file";
+} | {
+    kind: "dir";
+};
+export interface CompletionFlag {
+    /** Long name without the leading `--`. */
+    name: string;
+    /** Short character without the leading `-`. */
+    char?: string;
+    description: string;
+    value: ValueSource;
+    /** Flag may appear multiple times (oclif `multiple`). */
+    repeatable: boolean;
+}
+export interface CompletionArg {
+    name: string;
+    description: string;
+    value: ValueSource;
+}
+export interface CompletionCommand {
+    name: string;
+    aliases: readonly string[];
+    description: string;
+    flags: CompletionFlag[];
+    args: CompletionArg[];
+}
+export interface CompletionSpec {
+    bin: string;
+    /** Flags/args of the default (no-subcommand) command. */
+    root: {
+        flags: CompletionFlag[];
+        args: CompletionArg[];
+    };
+    commands: CompletionCommand[];
+}
+/**
+ * Build a {@link CompletionSpec} from loaded command classes.
+ *
+ * @param rootName  Entry name of the default command (its flags become top-level
+ *                  flags; it is excluded from the subcommand list).
+ * @param aliasMap  Canonical-name → aliases (merged from the registration table
+ *                  and the command class's static `aliases`).
+ */
+export declare function buildSpec(config: CliConfig, rootName: string, aliasMap: Map<string, readonly string[]>): CompletionSpec;
+export declare function generateCompletion(shell: Shell, spec: CompletionSpec): string;

package/dist/types/cli/config-cli.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Config CLI command handlers.
+ *
+ * Handles `jeopi config <command>` subcommands for managing settings.
+ * Uses the settings schema as the source of truth for available settings.
+ */
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg" | "migrate-legacy";
+export interface ConfigCommandArgs {
+    action: ConfigAction;
+    key?: string;
+    value?: string;
+    flags: {
+        json?: boolean;
+    };
+}
+/**
+ * Parse config subcommand arguments.
+ * Returns undefined if not a config command.
+ */
+export declare function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined;
+export declare function runConfigCommand(cmd: ConfigCommandArgs): Promise<void>;
+export declare function printConfigHelp(): void;

package/dist/types/cli/dry-balance-cli.d.ts

@@ -0,0 +1,113 @@
+import type { Api, AssistantMessageEventStream, AuthCredentialSnapshotEntry, Context, Model, OAuthAccess, OAuthAccessResolution, SimpleStreamOptions } from "jeopi-ai";
+import { Settings } from "../config/settings";
+export interface DryBalanceCommandArgs {
+    model?: string;
+    flags: {
+        model?: string;
+        count?: number;
+        concurrency?: number;
+        json?: boolean;
+        bench?: boolean;
+    };
+}
+export interface DryBalanceAuthOptions {
+    baseUrl?: string;
+    modelId?: string;
+    signal?: AbortSignal;
+}
+export interface DryBalanceAuthStorage {
+    getOAuthAccess(provider: string, sessionId?: string, options?: DryBalanceAuthOptions): Promise<OAuthAccess | undefined>;
+    getOAuthAccesses?(provider: string, options?: DryBalanceAuthOptions): Promise<OAuthAccessResolution[]>;
+    /**
+     * Force-refresh a single credential by id (step (b) of the auth-retry
+     * policy). The bench re-mints the failing account's token in place on a
+     * 401 rather than rotating accounts — it is measuring each account.
+     */
+    forceRefreshCredentialById?(id: number, signal?: AbortSignal): Promise<AuthCredentialSnapshotEntry>;
+}
+export interface DryBalanceModelRegistry {
+    authStorage: DryBalanceAuthStorage;
+    getAll(): Model<Api>[];
+    getAvailable(): Model<Api>[];
+    getApiKey(model: Model<Api>, sessionId?: string): Promise<string | undefined>;
+}
+export interface DryBalanceRuntime {
+    modelRegistry: DryBalanceModelRegistry;
+    settings?: Settings;
+    close?: () => void;
+}
+export interface DryBalanceAccountStat {
+    account: string;
+    count: number;
+    percent: number;
+}
+export interface DryBalanceFailureStat {
+    reason: string;
+    count: number;
+    percent: number;
+}
+export interface DryBalanceBenchSuccessResult {
+    ok: true;
+    account: string;
+    ttftMs: number;
+    durationMs: number;
+    outputTokens: number;
+    tokensPerSecond: number;
+}
+export interface DryBalanceBenchFailureResult {
+    ok: false;
+    account?: string;
+    error: string;
+}
+export type DryBalanceBenchResult = DryBalanceBenchSuccessResult | DryBalanceBenchFailureResult;
+export interface DryBalanceBenchSummary {
+    total: number;
+    success: {
+        total: number;
+        averageTtftMs: number | null;
+        averageTokensPerSecond: number | null;
+    };
+    failure: {
+        total: number;
+        reasons: DryBalanceFailureStat[];
+    };
+    results: DryBalanceBenchResult[];
+}
+export interface DryBalanceSummary {
+    model: string;
+    provider: string;
+    samples: number;
+    concurrency: number;
+    success: {
+        total: number;
+        accounts: DryBalanceAccountStat[];
+    };
+    failure: {
+        total: number;
+        reasons: DryBalanceFailureStat[];
+    };
+    bench?: DryBalanceBenchSummary;
+}
+type DryBalanceStreamSimple = (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
+export interface DryBalanceDependencies {
+    createRuntime?: () => Promise<DryBalanceRuntime>;
+    randomSessionId?: () => string;
+    writeStdout?: (text: string) => void;
+    writeStderr?: (text: string) => void;
+    setExitCode?: (code: number) => void;
+    streamSimple?: DryBalanceStreamSimple;
+    now?: () => number;
+    stdoutIsTTY?: boolean;
+    stderrIsTTY?: boolean;
+    stdoutColumns?: number;
+    stderrColumns?: number;
+}
+interface DryBalanceBenchProgressSink {
+    markRunning(index: number, account: string): void;
+    complete(index: number, result: DryBalanceBenchResult): void;
+    close(): void;
+}
+export declare function createBenchProgressSink(total: number, write: (text: string) => void, interactive: boolean, columns: number): DryBalanceBenchProgressSink;
+export declare function formatDryBalanceText(summary: DryBalanceSummary): string;
+export declare function runDryBalanceCommand(command: DryBalanceCommandArgs, deps?: DryBalanceDependencies): Promise<DryBalanceSummary>;
+export {};

package/dist/types/cli/extension-flags.d.ts

@@ -0,0 +1,36 @@
+import { type Args } from "./args";
+/**
+ * Minimal extension-runner surface needed to resolve CLI flag values. The real
+ * `ExtensionRunner` satisfies this structurally; depending only on the surface
+ * keeps this module free of the heavier runner/session imports and unit-testable
+ * with a fake.
+ */
+export interface ExtensionFlagSink {
+    getFlags(): Map<string, {
+        type: "boolean" | "string";
+    }>;
+    setFlagValue(name: string, value: boolean | string): void;
+}
+/**
+ * Resolve extension-registered CLI flags from `rawArgs` once the flag set is
+ * known, push the resolved values onto the sink, and return the parsed
+ * {@link Args} (whose `messages` and `fileArgs` now reflect those flags).
+ *
+ * The startup parse runs before extensions load, so it cannot recognise their
+ * flags: a string flag's value (`--spawn-peer reviewer` or `--spawn-peer=reviewer`)
+ * is otherwise left in `messages` and leaks into the initial prompt. Re-parsing
+ * here — through the *same* {@link parseArgs} the startup pass uses, now seeded
+ * with the registered flags — consumes every flag form (`--flag`, `--flag value`,
+ * `--flag=value`).
+ *
+ * {@link parseArgs} lets a registered flag shadow a same-named built-in, so even
+ * a built-in-colliding flag (e.g. plan-mode's boolean `--plan`, which would
+ * otherwise hit the built-in plan-model branch) is parsed with the extension's
+ * semantics and surfaces in `unknownFlags` — without consuming the following
+ * message or overwriting the built-in field. No built-in name list to maintain.
+ *
+ * Returns `null` when there is no sink or no registered extension flags, in
+ * which case the caller keeps its original startup parse (an extension-aware
+ * re-parse would be identical anyway).
+ */
+export declare function applyExtensionFlags(runner: ExtensionFlagSink | undefined, rawArgs: string[]): Args | null;

package/dist/types/cli/file-processor.d.ts

@@ -0,0 +1,11 @@
+import type { ImageContent } from "jeopi-ai";
+export interface ProcessedFiles {
+    text: string;
+    images: ImageContent[];
+}
+export interface ProcessFileOptions {
+    /** Whether to auto-resize images to 2000x2000 max. Default: true */
+    autoResizeImages?: boolean;
+}
+/** Process @file arguments into text, document content, and image attachments */
+export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;

package/dist/types/cli/flag-tables.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Single source of truth for argv flag classification, shared by:
+ *   - `parseArgs` in `./args.ts` (the launch-time CLI parser)
+ *   - `extractProfileFlags` in `./profile-bootstrap.ts` (the early
+ *     `--profile` / `--alias` pre-parser)
+ *
+ * `parseArgs` dispatches string-valued flags by looking up their setter in
+ * {@link STRING_SETTERS}. Optional-value flags use {@link OPTIONAL_FLAGS} so
+ * per-flag quirks (currently empty-string rejection for `--resume`) live here
+ * instead of being hard-coded in the dispatch loop.
+ *
+ * The bootstrap doesn't dispatch — it only needs to know which flags consume
+ * a value — so it consults {@link STRING_VALUE_FLAGS} and
+ * {@link OPTIONAL_VALUE_FLAGS}, both derived from `Object.keys(...)` on the
+ * setter/config records below.
+ *
+ * The deliberate consequence: a string-valued flag exists in this CLI surface
+ * iff it has an entry here. Adding a new string-valued flag means adding a
+ * setter/config entry in this file; both `args.ts` and the bootstrap pick it
+ * up automatically, so the two cannot drift out of sync.
+ *
+ * IMPORT RULE: this module MUST NOT import any runtime value from
+ * `jeopi-utils` (or anything that transitively does). That package's
+ * `env.ts` eagerly loads `.env` files from `getAgentDir()` during module
+ * initialization, which would race the profile bootstrap. Type-only imports
+ * are erased at runtime and are therefore safe.
+ *
+ * If a setter needs runtime dependencies (logging, validators, lookup
+ * tables), they're passed in through {@link ParseDeps} and `args.ts` wires the
+ * real implementations at the dispatch site.
+ */
+import type { ConfiguredThinkingLevel } from "../thinking";
+import type { Args } from "./args";
+/**
+ * Runtime dependencies injected into setters that need to validate input or
+ * warn about bad values. `args.ts` constructs one object at module load and
+ * passes it to each {@link STRING_SETTERS} call.
+ *
+ * Keeping these out of the setter closures means this module stays free of
+ * runtime imports from `jeopi-utils`, which is the whole reason it can
+ * be safely imported by `profile-bootstrap.ts` before `setProfile` runs.
+ */
+export interface ParseDeps {
+    logger: {
+        warn: (message: string, meta?: Record<string, unknown>) => void;
+    };
+    parseThinking: (value: string | null | undefined) => ConfiguredThinkingLevel | undefined;
+    builtinToolNames: readonly string[];
+    normalizeToolNames: (values: Iterable<string>) => string[];
+    thinkingEfforts: readonly string[];
+}
+export type StringSetter = (result: Args, value: string, deps: ParseDeps) => void;
+/**
+ * Setter for a flag that may or may not consume the next argv token.
+ * Receives `undefined` for the bare form (`--resume` with no value, etc.).
+ */
+export type OptionalSetter = (result: Args, value: string | undefined) => void;
+/**
+ * Per-flag optional-value consumption policy.
+ *
+ * Every optional flag always rejects tokens that start with `-` — that shared
+ * rule lives in the dispatch site. These booleans capture the *additional*
+ * per-flag quirks:
+ *
+ * - `rejectEmpty`: treat `""` like “no value provided”. Needed for
+ *   `--resume` / `-r` / `--session`. Without it, an empty string
+ *   gets consumed as the session prefix and downstream resolution can match
+ *   every session.
+ */
+export interface OptionalFlagConfig {
+    set: OptionalSetter;
+    rejectEmpty?: boolean;
+}
+/**
+ * Setters for flags with string values. Most built-ins consume the next argv
+ * token even when it starts with `-`; flags listed in
+ * {@link EXTENSION_SHADOWABLE_STRING_FLAGS} use extension-style consumption so
+ * a registered boolean extension can shadow them before profile bootstrap.
+ */
+export declare const STRING_SETTERS: Record<string, StringSetter>;
+/**
+ * Optional-value flags. Setters receive `undefined` for the bare form.
+ *
+ * The dispatch in `args.ts` applies the shared "doesn't start with `-`"
+ * check for every flag, then consults the per-flag booleans below for the
+ * remaining quirks.
+ */
+export declare const OPTIONAL_FLAGS: Record<string, OptionalFlagConfig>;
+/**
+ * Derived from {@link STRING_SETTERS}. A flag is in this set if and only if
+ * it has a setter — by construction, drift between "the bootstrap thinks
+ * this flag accepts a value" and "the launch parser can set one" is
+ * structurally impossible.
+ */
+export declare const STRING_VALUE_FLAGS: ReadonlySet<string>;
+/**
+ * Built-in string flags known to be shadowed by bundled/common boolean
+ * extensions before extension metadata is available. They still accept a
+ * value-like successor for the built-in form (`--plan opus`), but a
+ * flag-looking successor remains a fresh flag (`--plan --profile work`).
+ */
+export declare const EXTENSION_SHADOWABLE_STRING_FLAGS: ReadonlySet<string>;
+/**
+ * Derived from {@link OPTIONAL_FLAGS}. Same single-source contract as
+ * {@link STRING_VALUE_FLAGS}.
+ */
+export declare const OPTIONAL_VALUE_FLAGS: ReadonlySet<string>;
+/**
+ * Internal marker inserted by the profile bootstrap when removing `--profile`
+ * or `--alias` would otherwise make the following value-like token become the
+ * value of a preceding optional/extension flag. `parseArgs` ignores it, but its
+ * flag-looking shape preserves argv boundaries during the second parse.
+ */
+export declare const PROFILE_BOOTSTRAP_BOUNDARY_ARG = "--jeopi-profile-boundary";
+/**
+ * Long-form launch flags that take NO value (booleans). The bootstrap pre-parser
+ * needs this to tell a known value-less flag (whose successor is a fresh
+ * argument — `jeopi --print --profile work` still selects a profile) apart from an
+ * UNKNOWN long option that might be an extension string flag consuming the next
+ * token as its value (so the bootstrap must not steal that token as a global
+ * `--profile`/`--alias`). MUST mirror the value-less flag arms of `parseArgs`
+ * in `./args.ts`: adding a new boolean launch flag there means adding it here,
+ * or `--<newflag> --profile X` stops selecting a profile. Short aliases
+ * (`-h`/`-v`/`-c`/`-p`) are intentionally omitted — the protection rule only
+ * fires for `--`-prefixed tokens.
+ */
+export declare const VALUELESS_FLAGS: ReadonlySet<string>;
+/**
+ * Whether a bare long option (`--xxx`, no `=`) is unclassified — not a known
+ * string-, optional-, or value-less flag. The bootstrap and subcommand
+ * resolver treat these as possible extension string flags that may consume a
+ * value-like successor (the extension flag table is not yet loaded). Shared so
+ * both call sites classify identically.
+ */
+export declare function isUnknownLongValueCandidate(arg: string): boolean;
+/**
+ * Whether a leading option `flag` consumes the following argv token `next` as
+ * its value, applying the same contract as `extractProfileFlags` / `parseArgs`.
+ * Single source of truth so subcommand detection ({@link resolveCliArgv}) skips
+ * a flag's value instead of mistaking it for the subcommand — `jeopi --model acp`
+ * means model `acp`, not the `acp` subcommand, exactly as the launch parser
+ * reads it.
+ */
+export declare function flagConsumesValue(flag: string, next: string | undefined): boolean;

package/dist/types/cli/gallery-cli.d.ts

@@ -0,0 +1,49 @@
+import { type GalleryFixture } from "./gallery-fixtures";
+/** Lifecycle states the gallery renders, in display order. */
+export declare const GALLERY_STATES: readonly ["streaming", "progress", "success", "error"];
+export type GalleryState = (typeof GALLERY_STATES)[number];
+/** User-facing labels printed above each rendered lifecycle state. */
+export declare const GALLERY_STATE_LABELS: Record<GalleryState, string>;
+/** Accepted `--state` tokens, including legacy lifecycle names and displayed labels. */
+export declare const GALLERY_STATE_TOKENS: string[];
+/** Normalize user-provided `--state` tokens to the internal gallery lifecycle states. */
+export declare function parseGalleryStates(states: readonly string[] | undefined): GalleryState[] | undefined;
+export interface GalleryCommandArgs {
+    /** Render width in columns (defaults to terminal width, clamped). */
+    width?: number;
+    /** Restrict to a single tool name. */
+    tool?: string;
+    /** Restrict to specific lifecycle states. */
+    states?: GalleryState[];
+    /** Render the expanded variant of each renderer. */
+    expanded?: boolean;
+    /** Strip ANSI styling from the output (useful when redirecting to a file). */
+    plain?: boolean;
+    /** Capture the rendered gallery as PNG screenshot(s) via VHS instead of printing ANSI. */
+    screenshot?: boolean;
+    /** Screenshot output path (single image) or base path (suffixed when split across images). */
+    out?: string;
+    /** Font family for screenshots (must be installed; Nerd Font recommended for icon glyphs). */
+    font?: string;
+    /** Font size in points for screenshots. */
+    fontSize?: number;
+}
+/** One tool's rendered lifecycle, as ANSI lines: a leading blank, the section rule, then each state. */
+export interface GallerySection {
+    heading: string;
+    lines: string[];
+}
+/** The curated fixture for a tool, or a generic one for registry tools lacking sample data. */
+export declare function resolveFixture(name: string): GalleryFixture;
+/**
+ * Render a single tool/state pair to lines. Builds a fresh component, drives it
+ * to the requested state, settles any async edit preview, then snapshots the
+ * render and stops all animation timers.
+ */
+export declare function renderGalleryState(name: string, fixture: GalleryFixture, state: GalleryState, width: number, expanded?: boolean): Promise<readonly string[]>;
+/**
+ * Render the gallery. Iterates the renderer registry (or a single tool),
+ * printing each requested lifecycle state under a labeled section — or, with
+ * `screenshot`, capturing the rendered output as PNG(s) via VHS.
+ */
+export declare function runGalleryCommand(args: GalleryCommandArgs): Promise<void>;

package/dist/types/cli/gallery-fixtures/agentic.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const agenticFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/codeintel.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the code-intelligence tools (lsp, debug). */
+import type { GalleryFixture } from "./types";
+export declare const codeintelFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/edit.d.ts

@@ -0,0 +1,3 @@
+/** Gallery fixtures for the edit tools (edit, apply_patch, ast_edit). */
+import type { GalleryFixture } from "./types";
+export declare const editFixtures: Record<string, GalleryFixture>;

package/dist/types/cli/gallery-fixtures/fs.d.ts

@@ -0,0 +1,2 @@
+import type { GalleryFixture } from "./types";
+export declare const fsFixtures: Record<string, GalleryFixture>;