@lmctl-ai/lmctl 0.1.341 → 0.2.2

package/dist/providers/pricing.d.ts

@@ -0,0 +1,107 @@
+import type { AliasTable } from "./model-catalog.js";
+export declare const PRICE_DATA_URL = "https://lmctl.com/dataset/model_list.json";
+export declare const PRICE_ALIASES_URL = "https://lmctl.com/dataset/aliases.json";
+export type PriceDataSource = "network" | "cache" | "bundled" | "pinned" | "unavailable";
+export interface PriceRecord {
+    source: string;
+    source_model_id: string;
+    provider?: string | null;
+    mode?: string | null;
+    record_id?: string | null;
+    gateway_id?: string | null;
+    context_window?: {
+        input_tokens?: number | null;
+    } | null;
+    pricing: {
+        input_per_1m_tokens: number | null;
+        output_per_1m_tokens: number | null;
+        input_cache_read_per_1m_tokens: number | null;
+    };
+}
+export interface PriceCatalog {
+    schema_version: number;
+    generated_at: string;
+    records: PriceRecord[];
+}
+export interface PriceDataResult {
+    catalog: PriceCatalog | null;
+    source: PriceDataSource;
+    generatedAt: string | null;
+}
+export interface CatalogSnapshot {
+    catalog: PriceCatalog | null;
+    aliases: AliasTable | null;
+    source: PriceDataSource;
+    generatedAt: string | null;
+}
+export declare function isValidCatalog(payload: unknown): payload is PriceCatalog;
+export declare function isValidAliases(payload: unknown): payload is AliasTable;
+export interface LoadCatalogOptions {
+    fetchImpl?: typeof fetch;
+    cacheDir?: string;
+    /** Override for the bundled model_list path; `null` disables that fallback. */
+    bundledPath?: string | null;
+    /** Override for the bundled aliases path; `null` disables that fallback. */
+    bundledAliasesPath?: string | null;
+    /** Override for LMCTL_PRICE_DATA; `null` forces unpinned. */
+    pinDir?: string | null;
+    /** Test seam for the TTL gate (defaults to Date.now()). */
+    now?: number;
+    /** Test seam overriding LMCTL_PRICE_TTL (ms). */
+    ttlMs?: number;
+}
+/** Dataset generated_at of the most recently loaded snapshot, for --debug surfaces. */
+export declare function datasetGeneratedAt(): string | null;
+/** Test seam: drop the memoized no-argument snapshot (process-level memo). */
+export declare function _resetCatalogSnapshotMemoForTests(): void;
+/**
+ * The one snapshot loader for the lmprice integration. Never throws. One
+ * snapshot load per process invocation: the no-argument call (the normal
+ * command path) is memoized module-wide, so lint/seed/cost members never
+ * trigger per-member re-downloads; calls with explicit options (tests,
+ * seams) always execute.
+ */
+export declare function loadCatalogSnapshot(opts?: LoadCatalogOptions): Promise<CatalogSnapshot>;
+/**
+ * The one function `lmctl cost`'s Phase 1 callers use. Never throws, never
+ * blocks longer than `VERSION_CHECK_TIMEOUT_MS` for the "is there anything
+ * new" check regardless of network state (per resource, outside the TTL) --
+ * a HEAD request specifically so a slow/large BODY download can never blow
+ * that budget. Thin wrapper over loadCatalogSnapshot: the model-list half
+ * of the snapshot with the same result shape as before the two-resource
+ * extension.
+ */
+export declare function loadPriceData(opts?: LoadCatalogOptions): Promise<PriceDataResult>;
+/**
+ * Records are source-specific and NOT reconciled across sources (lmprice's
+ * own documented behavior) -- the same model can appear many times (bare id,
+ * `vendor/id`, `region/vendor/id`, ...) with the litellm and openrouter
+ * sources potentially disagreeing. `records` is already sorted by
+ * (source, provider, source_model_id) -- "litellm" sorts before "openrouter"
+ * -- so preferring the first exact-bare-id match, then the first
+ * suffix (`/<modelId>`) match, is a deterministic, if arbitrary, tie-break
+ * rather than an average/reconciliation across disagreeing sources.
+ *
+ * Superseded for provider-aware resolution by model-catalog.ts's
+ * resolveModel(); kept for `lmctl cost` Phase 1 compatibility.
+ */
+export declare function findModelPrice(catalog: PriceCatalog, modelId: string): PriceRecord["pricing"] | null;
+/**
+ * Phase 1 cost model (approved design): the session's existing AGGREGATE
+ * token totals x one model's rate -- not a true per-model breakdown (see
+ * `runCost`'s `approximate` flag for when a session touched more than one
+ * model; that's a separate, later sub-task). `cachedInput` is priced at the
+ * cache-READ rate only -- lmprice's `input_cache_write_per_1m_tokens` isn't
+ * consumed here because lctl-src's own token accounting
+ * (`totalCachedInputTokens`) has never distinguished cache-write from
+ * cache-read tokens; conflating them into the (usually cheaper) read rate
+ * would UNDERSTATE cost for a cache-write-heavy session, but overstating via
+ * the (usually pricier) write rate for every cache hit is worse on average.
+ * Returns `null` when any needed price is missing -- never a partial/guessed
+ * number.
+ */
+export declare function computeCostUsd(tokens: {
+    input: number;
+    output: number;
+    cachedInput: number;
+}, pricing: PriceRecord["pricing"] | null): number | null;

package/dist/providers/qwen.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Qwen Code session provider.
+ *
+ * Qwen Code is a Claude Code fork — same JSONL session format in ~/.qwen/.
+ * This provider reuses the Claude provider logic with Qwen-specific paths.
+ */
+import type { SessionProvider, SessionSummary, SessionDetail } from "./types.js";
+interface QwenProviderOptions {
+    qwenDir?: string;
+}
+export declare class QwenProvider implements SessionProvider {
+    name: "qwen";
+    private baseDir;
+    constructor(opts?: QwenProviderOptions);
+    discoverSessions(): Promise<SessionSummary[]>;
+    private extractSummary;
+    loadSession(sessionId: string): Promise<SessionDetail | null>;
+    private loadFromFile;
+    resolveSessionPath(sessionId: string): Promise<string | null>;
+    deleteSession(sessionId: string): Promise<boolean>;
+}
+export {};

package/dist/providers/ratelimit-readings.d.ts

@@ -0,0 +1,32 @@
+export declare const VALID_RATELIMIT_TARGETS: readonly ["all", "codex", "agy", "claude", "kimi"];
+export interface RatelimitRunResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    signal?: string | null;
+    error?: (Error & {
+        code?: string;
+    }) | undefined;
+}
+export type RatelimitRunner = (bin: string, args: string[], timeoutMs: number) => RatelimitRunResult;
+export interface RatelimitFsDeps {
+    exists(path: string): boolean;
+}
+export declare function _setRatelimitRunnerForTests(fn: RatelimitRunner | null): void;
+export declare function _setRatelimitFsDepsForTests(deps: Partial<RatelimitFsDeps> | null): void;
+export interface RatelimitReadingsOptions {
+    providers?: string[];
+    targets?: string[];
+    timeoutSeconds?: number;
+    env?: NodeJS.ProcessEnv;
+    progress?: (message: string) => void;
+}
+export type RatelimitReadingsResult = {
+    status: 'ok';
+    readings: Record<string, unknown>[];
+} | {
+    status: 'error';
+    error: string;
+    readings: [];
+};
+export declare function queryRatelimitReadings(options?: RatelimitReadingsOptions): RatelimitReadingsResult;

package/dist/providers/registry.d.ts

@@ -0,0 +1,31 @@
+import type { SessionProvider, SessionSummary, SessionDetail, ProviderName, WatchTarget } from "./types.js";
+import type { ProviderAdapter } from "./adapter.js";
+export type { ProviderAdapter };
+export declare class ProviderRegistry {
+    private providers;
+    private adapters;
+    register(provider: SessionProvider): void;
+    listAll(filter?: {
+        provider?: ProviderName;
+        workspace?: string;
+        limit?: number;
+        from?: Date;
+        to?: Date;
+    }): Promise<SessionSummary[]>;
+    getSession(sessionId: string, provider?: ProviderName): Promise<SessionDetail | null>;
+    resolveSession(sessionId: string, provider?: ProviderName): Promise<{
+        provider: SessionProvider;
+        filePath: string;
+    } | null>;
+    resolveSessions(sessionId: string, provider?: ProviderName): Promise<Array<{
+        provider: SessionProvider;
+        filePath: string;
+    }>>;
+    getWatchTargets(): WatchTarget[];
+    deleteSession(sessionId: string, provider?: ProviderName): Promise<boolean>;
+    registerAdapter(adapter: ProviderAdapter): void;
+    getAdapter(name: ProviderName): ProviderAdapter | undefined;
+    getAllAdapters(): ProviderAdapter[];
+}
+export declare function createRegistry(...providers: SessionProvider[]): ProviderRegistry;
+export declare function createAdapterRegistry(adapters: ProviderAdapter[]): ProviderRegistry;

package/dist/providers/resume.d.ts

@@ -0,0 +1,43 @@
+import type { ProviderName, SessionDetail } from './types.js';
+export interface ResumeModelIgnored {
+    provider: string;
+    model: string;
+    reason: string;
+}
+/**
+ * Defensive sessionid format guard for the step-in spawn (design §2.4 /
+ * §10.B B3). Provider-minted ids are UUID-/slug-class; anything else is
+ * refused before any spawn (no shell, no injection surface).
+ */
+export declare const SESSIONID_RE: RegExp;
+export declare function isResumableProvider(p: string): p is ProviderName;
+/** Test-only: drop the cached registry between cases. */
+export declare function _resetResumeRegistryForTests(): void;
+/**
+ * The native resume incantation as an argv array (argv[0] is the PROVIDER
+ * binary — never lmctl). Returns null if `provider` has no registered
+ * adapter / resumable template. Tokenizes the native `resumeTemplate`
+ * (no quoted args in any template) and appends the YOLO suffix.
+ */
+export declare function resumeIncantationArgv(provider: string, sessionId: string, opts?: {
+    isLead?: boolean;
+    model?: string;
+    onModelIgnored?: (ignored: ResumeModelIgnored) => void;
+}): string[] | null;
+/** Display form of {@link resumeIncantationArgv} (seed-print + >200K UX). */
+export declare function resumeIncantationString(provider: string, sessionId: string, opts?: {
+    model?: string;
+}): string | null;
+/**
+ * Provider-agnostic session read (no provider round-trip, no `tokens`):
+ * the native per-provider session reader the registry already owns.
+ */
+export declare function loadSessionDetail(sessionId: string, provider: ProviderName): Promise<SessionDetail | null>;
+/**
+ * P2 — bare-sessionid auto-detect: ask the registry which provider(s)
+ * a sessionid resolves to. Returns matching provider names (0/1/N).
+ * Callers map 0 ⇒ not-found, 1 ⇒ use that provider, N ⇒ ambiguous (ask
+ * the user to pass `--provider`). Thin wrapper over the existing
+ * `registry().resolveSessions` — no new coupling.
+ */
+export declare function findSessionProviders(sessionId: string): Promise<ProviderName[]>;

package/dist/providers/seed-instruction.d.ts

@@ -0,0 +1,3 @@
+export declare const SEED_ACK = "ACK: waiting for explicit lmctl task.";
+export declare const SEED_INITIAL_PROMPT: string;
+export declare const MANUAL_SEED_POST_LAUNCH_NOTE = "send this exact lmctl seed instruction: \"lmctl seed initial connection only. Create or pin this provider session, then stop. Do not inspect files, run commands, infer a task, delegate, or edit. A dispatch that dies mid-turn is usually a timeout you set -- use --idle-timeout, not a shell timeout. Reply exactly: ACK: waiting for explicit lmctl task.\"";

package/dist/providers/self-session-env.d.ts

@@ -0,0 +1,21 @@
+export declare const LMCTL_SELF_SESSIONID = "LMCTL_SELF_SESSIONID";
+export declare const LMCTL_LAUNCH_SOURCE = "LMCTL_LAUNCH_SOURCE";
+export type LmctlLaunchSource = 'chat' | 'terminal' | 'unknown';
+/**
+ * A shell/profile can export `CLAUDE_CODE_EXECPATH` pointing at a binary
+ * for the WRONG platform (a real incident: a WSL environment inherited a
+ * Windows `claude.exe` from a cross-platform npm install). The `claude`
+ * CLI itself trusts this override unconditionally and re-execs into it,
+ * so a bad value there breaks every claude-provider spawn with a generic
+ * "native binary not installed" error that reads as a global install
+ * problem rather than one bad env var. lmctl can't fix the CLI's own
+ * re-exec logic, but it fully controls the env it hands the child, so it
+ * strips an override that's clearly wrong for the current platform
+ * (non-Windows + `.exe`, or a path that doesn't exist) before spawning —
+ * the child then falls back to its own default binary discovery instead
+ * of blindly trusting a broken pointer.
+ */
+export declare function sanitizeClaudeExecPathEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function withProviderCwdEnv(env: NodeJS.ProcessEnv | undefined, cwd: string): NodeJS.ProcessEnv;
+export declare function withSelfSessionEnv(env: NodeJS.ProcessEnv | undefined, sessionId: string | undefined): NodeJS.ProcessEnv | undefined;
+export declare function withProviderSpawnEnv(env: NodeJS.ProcessEnv | undefined, cwd: string, sessionId: string | undefined, launchSource?: LmctlLaunchSource): NodeJS.ProcessEnv;

package/dist/providers/session-limit.d.ts

@@ -0,0 +1,9 @@
+import type { ConversationMessage } from './types.js';
+export interface SessionLimitState {
+    state: 'LIMITED';
+    resets_at: string | null;
+    reset_time: string;
+    timezone: string | null;
+    detected_at: string;
+}
+export declare function detectSessionLimit(messages: ConversationMessage[]): SessionLimitState | null;

package/dist/providers/strip-ansi.d.ts

@@ -0,0 +1,5 @@
+/** Strips ANSI/VT100 escape sequences (color codes, etc.) so provider error
+ *  text captured from a child process's stderr reads as plain text instead
+ *  of literal escape-code noise wherever it's surfaced (a captured log, a
+ *  terminal that doesn't render them, JSON output). */
+export declare function stripAnsiCodes(text: string): string;

package/dist/providers/transport-errors.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Named error taxonomy for the transport layer (claude stream-json,
+ * codex app-server, ACP). Replaces the prior `new Error("RPC error: ...")`
+ * string-dump pattern with typed classes that preserve structured fields
+ * so downstream callers can branch on numeric codes / inspect the raw
+ * line / read the original cause without re-parsing the message.
+ *
+ * Shape mirrors the claude-agent-sdk-python error hierarchy
+ * (CLIConnectionError / CLINotFoundError / ProcessError /
+ * CLIJSONDecodeError / MessageParseError) flagged in
+ * `tasks/83-claude-sdk-research.md` §4 takeaway 3, and the
+ * `createRpcError` helper that the codex-app-server transport
+ * adopted from openai/codex-plugin-cc (research:
+ * `tasks/83-codex-transport-compare.md`).
+ *
+ * All classes extend `TransportError`, which extends `Error` — every
+ * instance still satisfies `instanceof Error` so existing
+ * `try/catch (e: unknown)` sites continue to work without changes.
+ * The added discriminator is `instanceof TransportError` (and the
+ * specific subclasses) for callers who want the structured fields.
+ *
+ * The existing `TurnAbortError` (in `base-adapter.ts`) is a separate
+ * concern — user-/idle-/provider-cancel reasons surfaced by the
+ * higher-level chat orchestrator — and lives outside this taxonomy.
+ */
+/**
+ * Base class for transport-layer failures. Carries `name` set to the
+ * concrete subclass name (so error messages on uncaught throws
+ * identify the subtype) and propagates `cause` per the standard
+ * Error options shape.
+ */
+export declare class TransportError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Failed to establish or maintain the subprocess/stdio channel.
+ * Examples: `spawn` ENOENT, `spawn` permission denied, write to
+ * already-closed stdin during a transport-level shutdown.
+ */
+export declare class TransportConnectionError extends TransportError {
+}
+/**
+ * The subprocess exited unexpectedly — either before the protocol
+ * reached its terminal state, or with a non-zero exit code that the
+ * transport considers an error condition.
+ *
+ * `exitCode` is `null` when the child was killed by signal without an
+ * explicit exit code; `signal` carries the POSIX signal name in that
+ * case (e.g. `"SIGKILL"`). `stderr` is best-effort — the transport
+ * captures the tail of the child's stderr if it was piped.
+ */
+export declare class TransportProcessError extends TransportError {
+    readonly exitCode: number | null;
+    readonly signal: string | null;
+    readonly stderr?: string | undefined;
+    constructor(message: string, exitCode: number | null, signal?: string | null, stderr?: string | undefined);
+}
+/**
+ * A line read off the wire could not be JSON-parsed. The raw `line`
+ * is preserved (truncated to a sane length by the caller before
+ * construction if it could be very large) so investigators can see
+ * exactly what the transport rejected. `cause` is the original
+ * `SyntaxError` from `JSON.parse`.
+ */
+export declare class TransportJsonError extends TransportError {
+    readonly line: string;
+    constructor(message: string, line: string, cause: unknown);
+}
+/**
+ * The peer responded with a JSON-RPC error object. `rpcCode` is the
+ * numeric code from the JSON-RPC `error.code` field when present, and
+ * `rpcData` carries the entire `error` payload (including `message`,
+ * `data`, and any provider-specific fields like
+ * codex-plugin-cc's broker-busy sentinel `-32001`).
+ *
+ * Callers who care about specific codes branch on `err.rpcCode`;
+ * generic catchers see a plain `Error` with a human-readable message.
+ */
+export declare class TransportRpcError extends TransportError {
+    readonly rpcCode?: number;
+    readonly rpcData?: unknown;
+    constructor(message: string, rpcCode?: number, rpcData?: unknown);
+}
+/**
+ * Convenience constructor that mirrors the prior `createRpcError`
+ * helper signature in `codex-app-server.ts`: pass the human message
+ * plus the raw JSON-RPC error object, and the helper extracts
+ * `code` (if numeric) and stores the whole object as `rpcData`.
+ *
+ * This is the migration target for `createRpcError` callers.
+ */
+export declare function transportRpcErrorFromResponse(message: string, errorObj?: unknown): TransportRpcError;

package/dist/providers/transport-lifecycle.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Graceful-shutdown ladder for transport child processes.
+ *
+ * Replaces the prior `child.kill()` (synchronous, hard SIGTERM, no
+ * grace) pattern across the claude / codex / ACP transports. The bug
+ * this fixes is documented in the claude-agent-sdk-python transport
+ * (`subprocess_cli.py:548-568` and the linked issue #625): when
+ * `claude` is killed mid-flush its session JSONL loses the last
+ * assistant message. The same risk class applies to any provider CLI
+ * that persists state on shutdown — codex (`thread/*.jsonl`),
+ * opencode (`opencode.db`), gemini (`~/.gemini/tmp/.../chats/`).
+ *
+ * Ladder:
+ *   1. (optional) close stdin so the child observes EOF.
+ *   2. wait `softDelayMs` for the child to exit on its own.
+ *   3. send SIGTERM (or `taskkill /T /F /PID <pid>` on Windows) and
+ *      wait `killDelayMs`.
+ *   4. send SIGKILL (no-op on Windows, taskkill is already hard).
+ *   5. wait up to a fixed final grace for the exit event before
+ *      returning.
+ *
+ * Returns a `TerminateResult` describing which path actually ended
+ * the child and total elapsed wall-clock — useful for tests and for
+ * future telemetry on shutdown latency.
+ */
+import type { ChildProcess } from "node:child_process";
+export interface TerminateOptions {
+    /** Call `child.stdin?.end()` first to signal clean EOF. Default: true. */
+    stdinEnd?: boolean;
+    /** Wait ms for child to exit naturally after stdin.end. Default: 5000. */
+    softDelayMs?: number;
+    /** Wait ms after SIGTERM before SIGKILL. Default: 5000. */
+    killDelayMs?: number;
+    /**
+     * Test seam — replace the Windows process-tree killer
+     * (`taskkill /T /F /PID <pid>`) with a no-op or recorder. Defaults
+     * to a real `spawnSync("taskkill", ...)` call on Windows; ignored
+     * on Unix.
+     */
+    runTaskkill?: (pid: number) => void;
+    /** Test seam — override `process.platform`. */
+    platform?: NodeJS.Platform;
+}
+/** Which step in the ladder actually finished the child. */
+export type TerminateSignal = "natural" | "stdin" | "SIGTERM" | "SIGKILL" | "abandoned";
+export interface TerminateResult {
+    signal: TerminateSignal;
+    elapsedMs: number;
+}
+/**
+ * Gracefully terminate a transport child process.
+ *
+ * Safe to call on an already-exited child (returns immediately with
+ * `signal: "natural"`). Safe to call multiple times concurrently
+ * — each call observes the same exit event independently.
+ *
+ * Errors are swallowed deliberately: this function is meant to be
+ * called from cleanup paths (abort handlers, IIFE catch blocks,
+ * timeout firings) where re-throwing would mask the original
+ * failure. Failures during termination are reflected in the returned
+ * `TerminateResult.signal` (`"abandoned"` is the only failure shape).
+ */
+export declare function terminateGracefully(child: ChildProcess, opts?: TerminateOptions): Promise<TerminateResult>;

package/dist/providers/transport-wrappers.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Transport wrappers for use by provider adapters.
+ * These wrap the existing transport modules, mapping their result types
+ * to the adapter's TurnResult.
+ *
+ * Each wrapper also classifies the transport's native event stream into
+ * normalized ProgressEvents (see adapter.ts) so that downstream consumers
+ * (idle timer, stderr printer) have a single format to deal with.
+ */
+import { type AcpMode } from "./transports/acp.js";
+import type { ProgressEvent, TurnOptions, TurnResult } from "./adapter.js";
+import type { BundleSession, BundleSessionOpenOptions } from "./bundle.js";
+/**
+ * Translate one stream-json event into zero or more ProgressEvents.
+ * Stream-json uses Claude's native message format:
+ *   - {"type":"system","subtype":"init",...}
+ *   - {"type":"assistant","message":{"content":[{type:"text"|"tool_use"|"thinking"...}]}}
+ *   - {"type":"user","message":{"content":[{type:"tool_result",...}]}}
+ *   - {"type":"result",...}
+ */
+/**
+ * Stateful factory for classifyStreamJsonEvent. The returned closure
+ * carries a per-turn id→startMs Map that lets it populate `elapsedMs`
+ * on tool_result events by correlating against the matching tool_use
+ * (Claude stream-json doesn't supply duration directly).
+ *
+ * Production callers (`streamJsonTurn`) instantiate ONCE per turn and
+ * reuse across all events. Unit tests that exercise a single event in
+ * isolation can keep using the bare `classifyStreamJsonEvent` free
+ * function below — they just won't get elapsedMs populated, which is
+ * fine because there's no matching pair to compute it from.
+ */
+export declare function makeStreamJsonClassifier(): (event: Record<string, unknown>, emit: (e: ProgressEvent) => void) => void;
+export declare function classifyStreamJsonEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
+export declare function streamJsonTurn(prompt: string, opts: TurnOptions & {
+    binary: string;
+}): Promise<TurnResult>;
+/**
+ * Open a persistent stream-json bundle session (batch bundle mode)
+ * for the claude/qwen adapters' `openSession`. Bundle resume is strict:
+ * the session file must exist and its header must carry the requested id.
+ */
+export declare function openStreamJsonBundleSession(opts: BundleSessionOpenOptions & {
+    binary: string;
+}): Promise<BundleSession>;
+/**
+ * Classify ACP session/update notifications. ACP wraps everything in
+ *   {"method":"session/update","params":{"update":{"sessionUpdate":"<kind>",...}}}
+ *
+ * Common sessionUpdate kinds (per the ACP spec used by Zed and friends):
+ *   - agent_message_chunk      → text (already streamed via onDelta)
+ *   - agent_thought_chunk      → thinking
+ *   - tool_call                → tool_use
+ *   - tool_call_update         → tool_result (completed/failed), other "running…" (in_progress)
+ *   - plan                     → other
+ */
+/**
+ * Stateful factory for classifyAcpEvent. Same shape and rationale as
+ * makeStreamJsonClassifier — see that doc. Carries per-turn id→startMs
+ * for the tool_call → tool_call_update correlation that drives
+ * `elapsedMs` on tool_result events.
+ */
+export declare function makeAcpClassifier(): (event: Record<string, unknown>, emit: (e: ProgressEvent) => void) => void;
+export declare function classifyAcpEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
+export declare function acpTurn(prompt: string, opts: TurnOptions & {
+    binary: string;
+    acpTool?: string;
+    acpMode?: AcpMode;
+}): Promise<TurnResult>;
+/**
+ * Open a persistent ACP bundle session (batch bundle mode) for a
+ * provider adapter's `openSession` implementation. `acpTool`/`acpMode`
+ * mirror `acpTurn`; the lifecycle contract is in
+ * `src/providers/bundle.ts` and the engine in `transports/acp.ts`'s
+ * `openAcpSession`.
+ *
+ * Bundle resume is ALWAYS strict: requireResume is forced and the loaded
+ * session id must equal the requested id exactly.
+ */
+export declare function openAcpBundleSession(opts: BundleSessionOpenOptions & {
+    binary: string;
+    acpTool?: string;
+    acpMode?: AcpMode;
+}): Promise<BundleSession>;
+/**
+ * Classify Codex app-server JSON-RPC notifications.
+ *
+ * Per codex-rs/app-server/README.md (Turn events / Items), the per-item
+ * lifecycle is always: `item/started` → zero or more item-specific deltas
+ * → `item/completed`. Items are a tagged union (`item.type`) including
+ * `commandExecution`, `fileChange`, `mcpToolCall`, `webSearch`, `reasoning`,
+ * `agentMessage`, etc.
+ *
+ * Item-specific deltas we care about:
+ *   - item/agentMessage/delta              → text (already streamed via onDelta)
+ *   - item/reasoning/summaryTextDelta      → thinking
+ *   - item/reasoning/textDelta             → thinking
+ *   - item/commandExecution/outputDelta    → text (suppressed; lifecycle covers it)
+ */
+export declare function classifyCodexEvent(event: Record<string, unknown>, emit: (e: ProgressEvent) => void): void;
+export declare function codexAppServerTurn(prompt: string, opts: TurnOptions & {
+    binary: string;
+}): Promise<TurnResult>;
+/**
+ * Open a persistent codex app-server bundle session (batch bundle
+ * mode) for the codex adapter's `openSession`. Bundle resume is
+ * strict: thread/resume must succeed and return the exact requested
+ * thread id; the thread/start fallback is disabled in bundle mode.
+ */
+export declare function openCodexBundleSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;

package/dist/providers/transports/acp-profiles/config-option-step.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared `session/set_config_option` step factory for the profiles whose
+ * per-session model/effort surface is an ACP config option (opencode, kimi).
+ *
+ * The failure semantics are NON-FATAL by contract (task #232): the turn
+ * proceeds with whatever config was already active, and the drop is
+ * recorded on all three channels — stderr line, `acp_config_option_failed`
+ * errorLog record, and a warnings-channel entry that lands on
+ * `AcpResult.warnings`.
+ *
+ * "_failed", not "_rejected": the driver's catch wraps `sendRpc`, so it
+ * also fires on transport disconnect, not only on the provider rejecting
+ * the value. Naming it "rejected" would conflate provider-validation noise
+ * with channel failure — exactly the misreading these counts exist to
+ * prevent.
+ */
+import type { AcpSessionContext, AcpSessionStep } from "./types.js";
+export declare function setConfigOptionStep(opts: {
+    id: string;
+    provider: string;
+    configId: string;
+    /** The requested value; undefined ⇒ the step does not apply. */
+    value: (ctx: AcpSessionContext) => string | undefined;
+}): AcpSessionStep;

package/dist/providers/transports/acp-profiles/copilot.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copilot ACP profile.
+ *
+ * Copilot's `--acp` mode has no plan-mode flag and no per-session model
+ * selection surface (verified against copilot-cli 1.0.35). Both gaps are
+ * surfaced once per spawn — a stderr line the user sees plus an
+ * unconditional errorLog record fleet tooling can count — and the turn
+ * proceeds on the yolo/default surface rather than hanging on permission
+ * prompts it cannot answer.
+ */
+import type { AcpProviderProfile } from "./types.js";
+export declare const copilotProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/gemini.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Gemini ACP profile.
+ *
+ * Permission posture is argv-based: `-y` (yolo) works before or after
+ * `--acp`, and the companion `--skip-trust` is passed unconditionally —
+ * gemini's workspace-trust gate (~/.gemini/trustedFolders.json) downgrades
+ * approval mode to "default" in untrusted folders, silently disarming
+ * `-y`; `--skip-trust` is the per-invocation escape hatch (no-op in
+ * already-trusted folders). Plan mode swaps the `-y` token for
+ * `--approval-mode plan`, keeping companions intact.
+ *
+ * Caveat: gemini's `--approval-mode plan` only filters `write_file` by
+ * workspace path — the agent can still escape via `run_shell_command`
+ * (documented in yolo-contract.ts; a tighter sandbox is a follow-up).
+ *
+ * Gemini replays prior assistant chunks during `session/load` and
+ * concatenates earlier image turns into the reply text; keeping only the
+ * latest agent message is the output processor's job (parsers/acp.ts),
+ * wired in via `isolateResult`.
+ */
+import type { AcpProviderProfile } from "./types.js";
+export declare const geminiProfile: AcpProviderProfile;

package/dist/providers/transports/acp-profiles/hermes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hermes (Hermes Agent) ACP profile.
+ *
+ * `hermes acp` IS the ACP stdio server (same launcher as the `hermes-acp`
+ * console script); it takes no permission flag. The posture is two-part:
+ *
+ *  1. Shell gate: `HERMES_YOLO_MODE=1` on the process env (yolo mode only;
+ *     hermes REFUSES plan mode outright).
+ *  2. Edit gate: ACP `session/set_mode` — Hermes's mode ladder
+ *     (`HermesACPAgent._MODES`, `acp_adapter/server.py:233-243`) governs
+ *     the file-EDIT approval gate, which `HERMES_YOLO_MODE` does NOT
+ *     approve. An unset mode leaves every edit waiting on a
+ *     `session/request_permission` round-trip lmctl cannot answer, so the
+ *     mode is applied after session/new|load, before the model, on EVERY
+ *     spawn (the mode lives on the in-memory session), FAIL-CLOSED.
+ *
+ * Model selection is `session/set_model` (also fail-closed), NOT
+ * `session/set_config_option`: hermes's config-option handler stores an
+ * unrecognized configId verbatim and applies nothing
+ * (`acp_adapter/server.py:958-977`). Its model ids are the ENCODED
+ * `provider:model` form it advertises in session/new
+ * (`acp_adapter/model_catalog.py:146-152`) — a bare model name resolves
+ * the wrong provider. An unchanged model is not re-set (avoids rebuilding
+ * the Hermes agent).
+ */
+import type { AcpProviderProfile } from "./types.js";
+export declare const hermesProfile: AcpProviderProfile;