@lmctl-ai/lmctl 0.2.37 → 0.2.39

package/dist/providers/adapters/gemini-adapter.d.ts

@@ -1,44 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { ForkResult, ManualSeedHint, SeedOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createGeminiAdapter(opts?: {
-    geminiDir?: string;
-    claudeDir?: string;
-    codexDir?: string;
-    codeDir?: string;
-}): GeminiAdapter;
-declare class GeminiAdapter extends BaseProviderAdapter {
-    private readonly geminiDir?;
-    constructor(opts?: {
-        geminiDir?: string;
-        claudeDir?: string;
-        codexDir?: string;
-        codeDir?: string;
-    });
-    /** Bundle support (batch redesign item 2): one ACP process, many turns. */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    forkHint(_sessionId: string): string;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    /**
-     * Manual-seed hint with `--skip-trust` baked in. Without it, an
-     * interactive `gemini` launched in an untrusted folder hits the
-     * same workspace-trust gate that derailed auto-seed in the first
-     * place — the user would see "Approval mode overridden to
-     * 'default'" and the manual recovery would loop right back to
-     * the failure mode. The flag is a no-op in already-trusted
-     * folders, so always-on is safe.
-     */
-    manualSeedHint(sessiondir: string): ManualSeedHint;
-    /**
-     * Fork a Gemini session by copying its session file with a new
-     * session ID. Format-preserving: a `.json` source produces a
-     * `.json` fork; a `.jsonl` source produces a `.jsonl` fork.
-     *
-     * Gemini stores sessions in `~/.gemini/tmp/<project>/chats/`.
-     * Copying the file and changing the sessionId creates an
-     * independent branch — the conversation history is identical up
-     * to the fork point and diverges from there.
-     */
-    fork(sessionId: string, tag: string): Promise<ForkResult>;
-}
-export {};

package/dist/providers/adapters/hermes-adapter.d.ts

@@ -1,71 +0,0 @@
-/**
- * Hermes Agent ("hermes") provider adapter.
- *
- * Hermes is an ACP agent (`hermes acp`, protocolVersion 1, advertised
- * `loadSession: true`), so turns reuse lmctl's generic ACP transport —
- * one argv row in `transports/acp.ts`'s `ACP_TOOLS` table plus the
- * per-turn protocol gates documented there.
- *
- * Two things are genuinely Hermes-specific:
- *
- *  1. Seed is ACP, not a one-shot argv. Hermes has no headless print
- *     mode that writes a session this reader can find; `session/new`
- *     returns the id directly, and Hermes only persists a conversation
- *     once it has history (`acp_adapter/session.py` `_persist`).
- *     `seed()` therefore creates the session over ACP, sends the real
- *     seed prompt through the same turn path, and returns that exact id
- *     instead of diffing `discoverSessions()` around a subprocess.
- *
- *  2. `HERMES_HOME` is resolved ONCE here and travels on the spawned
- *     process's env as well as into the reader. Hermes reads that
- *     variable itself, so without it a caller that points the adapter at
- *     a home other than the ambient one gets a reader on one store and a
- *     child writing to another. A profile is a different home, not a
- *     subdirectory, so nothing else needs a profile knob.
- *
- * Plan mode: lmctl's `--permission-mode plan` is refused, not downgraded.
- * Hermes's ACP mode ladder (`default` / `accept_edits` / `dont_ask`)
- * governs its EDIT gate only and has no plan-equivalent, so sending its
- * most permissive edit policy for a plan request would escalate beyond
- * what was asked.
- *
- * Interactive resume, daemon sessions, fork and native deletion are outside v1.
- */
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions, SeedResult } from "../adapter.js";
-import type { AcpMode } from "../transports/acp.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function isHermesSessionId(sessionId: string): boolean;
-export declare function hermesAcpModeForPermissionMode(permissionMode: "plan" | "yolo" | undefined): AcpMode;
-export declare function createHermesAdapter(opts?: {
-    hermesHome?: string;
-}): HermesAdapter;
-declare class HermesAdapter extends BaseProviderAdapter {
-    private readonly hermesProvider;
-    /** The one home this adapter reads from AND spawns against. */
-    private readonly hermesHome;
-    constructor(opts?: {
-        hermesHome?: string;
-    });
-    /**
-     * Bundle support (batch redesign item 2): one ACP process, many turns.
-     * Carries the same Hermes-specific wiring as the per-turn transport —
-     * HERMES_HOME on the spawn env and the permission-mode → ACP mode
-     * mapping (plan is refused by the mapper). `async` so the plan refusal
-     * rejects the returned promise instead of throwing past the caller.
-     */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    /** Resolved store path — surfaced for tests and diagnostics. */
-    get stateDbPath(): string;
-    /**
-     * Create the session over ACP, send the real seed prompt so Hermes
-     * persists it, and return the exact session id `session/new` reported.
-     *
-     * `opts.model` is applied by the transport through Hermes's
-     * `session/set_model` (see `transports/acp.ts`). `opts.effort` is not
-     * wired: Hermes exposes reasoning effort via config/`--reasoning`, not
-     * through its ACP surface.
-     */
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-}
-export {};

package/dist/providers/adapters/index.d.ts

@@ -1,35 +0,0 @@
-/**
- * Provider adapter factory.
- *
- * Session-managing providers: claude, codex, gemini, copilot,
- * opencode, kimi, lmplayer, qwen, agy, dsh, and hermes. (R5 restored copilot/opencode/qwen after A0.2's
- * Phase-A narrowing to 3.)
- */
-export { createClaudeAdapter } from "./claude-adapter.js";
-export { createCodexAdapter } from "./codex-adapter.js";
-export { createGeminiAdapter } from "./gemini-adapter.js";
-export { createCopilotAdapter } from "./copilot-adapter.js";
-export { createOpenCodeAdapter } from "./opencode-adapter.js";
-export { createKimiAdapter } from "./kimi-adapter.js";
-export { createLmplayerAdapter } from "./lmplayer-adapter.js";
-export { createQwenAdapter } from "./qwen-adapter.js";
-export { createAgyAdapter } from "./agy-adapter.js";
-export { createDshAdapter } from "./dsh-adapter.js";
-export { createHermesAdapter } from "./hermes-adapter.js";
-export { createPiAdapter } from "./pi-adapter.js";
-export { createClaudeMockAdapter } from "../claude-mock.js";
-import type { ProviderAdapter } from "../adapter.js";
-export interface AdapterRegistryOpts {
-    claudeDir?: string;
-    codexDir?: string;
-    codeDir?: string;
-    geminiDir?: string;
-    copilotDir?: string;
-    agyDir?: string;
-    lmplayerDbPath?: string;
-    kimiHome?: string;
-    dshHome?: string;
-    hermesHome?: string;
-    piDir?: string;
-}
-export declare function createAllAdapters(opts?: AdapterRegistryOpts): ProviderAdapter[];

package/dist/providers/adapters/kimi-adapter.d.ts

@@ -1,16 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createKimiAdapter(opts?: {
-    kimiHome?: string;
-}): KimiAdapter;
-declare class KimiAdapter extends BaseProviderAdapter {
-    private readonly kimiHome?;
-    constructor(opts?: {
-        kimiHome?: string;
-    });
-    /** Bundle support (batch redesign item 2): one ACP process, many turns. */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-}
-export {};

package/dist/providers/adapters/lmplayer-adapter.d.ts

@@ -1,14 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions, SeedResult, ManualSeedHint } from "../adapter.js";
-export declare function createLmplayerAdapter(opts?: {
-    lmplayerDbPath?: string;
-}): LmplayerAdapter;
-declare class LmplayerAdapter extends BaseProviderAdapter {
-    constructor(opts?: {
-        lmplayerDbPath?: string;
-    });
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-    manualSeedHint(sessiondir: string): ManualSeedHint;
-}
-export {};

package/dist/providers/adapters/opencode-adapter.d.ts

@@ -1,11 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createOpenCodeAdapter(): OpenCodeAdapter;
-declare class OpenCodeAdapter extends BaseProviderAdapter {
-    constructor();
-    /** Bundle support (batch redesign item 2): one ACP process, many turns. */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-}
-export {};

package/dist/providers/adapters/pi-adapter.d.ts

@@ -1,17 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
-export declare function createPiAdapter(opts?: {
-    piDir?: string;
-}): PiAdapter;
-declare class PiAdapter extends BaseProviderAdapter {
-    constructor(opts?: {
-        piDir?: string;
-    });
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    manualSeedHint(sessiondir: string): {
-        launchCommand: string;
-        postLaunchNote: string;
-        lsCommand: string;
-    };
-}
-export {};

package/dist/providers/adapters/print-turn.d.ts

@@ -1,29 +0,0 @@
-/**
- * One-shot print transport — shared by providers whose CLI answers a prompt
- * in a single non-streaming invocation (`<binary> -p "<prompt>"` printing the
- * reply to stdout, e.g. agy, pi).
- *
- * Extracted from agy-adapter.ts so each provider only supplies its argv
- * shape; progress events, env wiring, abort handling, and error text stay
- * identical across providers.
- */
-import type { TurnOptions, TurnResult } from "../adapter.js";
-export interface PrintTurnConfig {
-    /** Provider label used in progress summaries and error messages. */
-    label: string;
-    /** Build the full argv (without the binary) for one turn. */
-    buildArgs: (prompt: string, opts: TurnOptions) => string[];
-    /** Optional argv assertion hook (e.g. the yolo contract for agy). */
-    assertArgs?: (args: string[], opts: TurnOptions) => void;
-}
-export declare function makePrintTurn(config: PrintTurnConfig): (prompt: string, opts: TurnOptions & {
-    binary: string;
-}) => Promise<TurnResult>;
-export declare function spawnCollect(label: string, command: string, args: string[], opts: {
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    signal?: AbortSignal;
-}): Promise<{
-    stdout: string;
-    stderr: string;
-}>;

package/dist/providers/adapters/qwen-adapter.d.ts

@@ -1,11 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createQwenAdapter(): QwenAdapter;
-declare class QwenAdapter extends BaseProviderAdapter {
-    constructor();
-    /** Bundle support (batch redesign item 2): one stream-json process, many turns. */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-}
-export {};

package/dist/providers/agy.d.ts

@@ -1,32 +0,0 @@
-/**
- * Antigravity CLI (`agy`) session provider.
- *
- * Antigravity stores local state under ~/.gemini/antigravity-cli but it is
- * not Gemini CLI: there is no ACP transport and transcripts have their own
- * JSONL event shape. Keep it as a distinct provider.
- */
-import type { SessionDetail, SessionProvider, SessionSummary } from "./types.js";
-interface AgyProviderOptions {
-    agyDir?: string;
-}
-export declare class AgyProvider implements SessionProvider {
-    name: "agy";
-    private baseDir;
-    constructor(opts?: AgyProviderOptions);
-    getWatchPaths(): {
-        directory: string;
-        filePattern: RegExp;
-    }[];
-    discoverSessions(): Promise<SessionSummary[]>;
-    private conversationPath;
-    private transcriptPath;
-    private existingTranscriptPath;
-    private extractSummary;
-    loadSession(sessionId: string): Promise<SessionDetail | null>;
-    resolveSessionPath(sessionId: string): Promise<string | null>;
-    deleteSession(sessionId: string): Promise<boolean>;
-    private resolveCwd;
-    private cwdFromLastConversationCache;
-    private readTaskLog;
-}
-export {};

package/dist/providers/base-adapter.d.ts

@@ -1,110 +0,0 @@
-/**
- * Base adapter — wraps an existing SessionProvider with default implementations
- * for seed, resume, start, and sendTurn. Provider-specific adapters override
- * what they need.
- */
-import type { SessionProvider, SessionSummary, SessionDetail, WatchPathInfo, ProviderName } from "./types.js";
-import type { ProviderAdapter, ProviderCapabilities, InjectionInfo, TurnOptions, TurnResult, SeedResult, SeedOptions, ManualSeedHint } from "./adapter.js";
-/**
- * Why a turn aborted before completing normally.
- *
- * - `external`    — lmctl received SIGINT/SIGTERM and forwarded the abort
- * - `provider`    — the upstream provider explicitly cancelled the turn
- *                   without completing normally
- */
-export type CancelReason = "external" | "provider";
-/**
- * Thrown when a turn is aborted (not completed normally). The
- * `cancelReason` field tells the catch site which path triggered it,
- * so the chat command can emit a tagged summary line + JSON record
- * instead of dropping the call's terminator entirely on every
- * cancellation.
- *
- * Task 65 finding 2 — every `lmctl chat` call must emit a
- * `[provider] N.Ns (cancelled: <reason>)` summary, regardless of
- * whether the call completed or aborted.
- */
-export declare class TurnAbortError extends Error {
-    readonly cancelReason: CancelReason;
-    constructor(message: string, cancelReason: CancelReason);
-}
-export interface BaseAdapterConfig {
-    provider: SessionProvider;
-    capabilities: ProviderCapabilities;
-    injection: InjectionInfo;
-    /** Binary name to invoke for this provider. */
-    binary: string;
-    /** Args for seeding a new session with the explicit seed instruction. */
-    seedArgs: string[];
-    /** Process timeout for the one-shot seed command. */
-    seedTimeoutMs?: number;
-    /** If seed input should be sent via stdin instead of args. */
-    seedStdin?: string;
-    /** Default resume command template. {{session_id}} is replaced. */
-    resumeTemplate: string;
-    /** Default start command. */
-    startTemplate: string;
-    /** Transport implementation for sendTurn. */
-    transport: (prompt: string, opts: TurnOptions & {
-        binary: string;
-    }) => Promise<TurnResult>;
-}
-export declare class BaseProviderAdapter implements ProviderAdapter {
-    readonly name: ProviderName;
-    readonly capabilities: ProviderCapabilities;
-    readonly injection: InjectionInfo;
-    protected provider: SessionProvider;
-    protected binary: string;
-    protected seedArgs: string[];
-    protected seedTimeoutMs: number;
-    protected seedStdin?: string;
-    protected resumeTemplate: string;
-    protected startTemplate: string;
-    protected transportFn: (prompt: string, opts: TurnOptions & {
-        binary: string;
-    }) => Promise<TurnResult>;
-    constructor(config: BaseAdapterConfig);
-    discover(): Promise<SessionSummary[]>;
-    load(sessionId: string): Promise<SessionDetail | null>;
-    resolvePath(sessionId: string): Promise<string | null>;
-    delete(sessionId: string): Promise<boolean>;
-    getWatchPaths(): WatchPathInfo[];
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    /** Per-provider hook to fill in a default `model` (or any other option)
-     *  when a member declares none. Identity by default -- override where a
-     *  provider's own CLI-level default isn't the right one for lmctl-driven
-     *  automation (see CodexAdapter). */
-    protected turnOptsFor(opts: TurnOptions): TurnOptions;
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-    resumeCommand(sessionId: string, profile?: string): string;
-    startCommand(_profile?: string): string;
-    /**
-     * Default manual-seed hint: launch the provider's binary in the
-     * member's sessiondir, send lmctl's explicit seed instruction to
-     * commit a waiting session file, then `lmctl ls` to find the new
-     * sessionid. Adapters with provider-specific quirks (e.g.
-     * gemini's `--skip-trust` for the workspace-trust gate) override
-     * this to inject the right flags.
-     */
-    manualSeedHint(sessiondir: string): ManualSeedHint;
-    /** Default idle timeout: 8 hours without any provider activity. */
-    static readonly DEFAULT_IDLE_TIMEOUT_MS: number;
-    sendTurn(prompt: string, rawOpts: TurnOptions): Promise<TurnResult>;
-    /**
-     * Run transport with idle timeout + signal forwarding.
-     *
-     * Idle timer resets on **any** ProgressEvent from the transport (text,
-     * tool_use, tool_result, thinking, system). It only fires if the provider
-     * goes completely silent for idleTimeoutMs.
-     *
-     * When the idle timer fires, the turn **resolves** with
-     * `{ status: "stalled", stalledAfterMs }` — it does NOT kill the
-     * child process. The child continues running; it's the caller's
-     * responsibility to decide what to do. (Timeout redesign Phase 2.)
-     */
-    private withTimeouts;
-    /**
-     * Run a user-defined one-shot agent command (from user-config `agent = ...`).
-     */
-    private runOneShotAgent;
-}

package/dist/providers/base.d.ts

@@ -1,12 +0,0 @@
-export declare const HOME_DIR: string;
-export declare function readJsonl<T = unknown>(filePath: string): AsyncGenerator<T>;
-export declare function readFirstJsonlLines<T = unknown>(filePath: string, maxLines: number): Promise<T[]>;
-export declare function getFileTimes(filePath: string): Promise<{
-    createdAt: Date;
-    modifiedAt: Date;
-}>;
-export declare function unescapeContent(text: string): string;
-export declare function escapeContent(text: string): string;
-export declare function truncate(text: string, maxLen: number): string;
-export declare function structuredToolInput(value: unknown): Record<string, unknown> | undefined;
-export declare function formatTimestamp(date: Date): string;

package/dist/providers/binary-check.d.ts

@@ -1,102 +0,0 @@
-/**
- * Provider-binary-on-PATH + runtime pre-flight check.
- *
- * Used by `lmctl lint` (warn the user about missing / broken CLI
- * installs at config-validation time) and `lmctl autocode` (HARD
- * GATE — refuse to spawn `lmctl seed` / `lmctl chat` if any
- * declared provider's CLI is missing or fails to execute, so we
- * never half-create a team).
- *
- * Implementation: `<binary> --version`. Cross-platform (no `which`
- * / `where` branching) and verifies strictly more than existence —
- * the binary must actually run to a clean exit. Catches:
- *   - not installed        → spawn returns ENOENT
- *   - installed but broken → non-zero exit (missing deps, bad libs,
- *                            permission denied, etc.)
- *   - installed and OK     → exit 0 with a version string on stdout
- *
- * All supported providers (claude/codex/copilot/gemini/opencode/lmplayer/qwen/agy)
- * accept `--version` and early-exit before any auth/config check, so
- * the pre-flight is cheap and safe to run on every lint/autocode.
- */
-/**
- * Map from our `ProviderName` → expected CLI binary on PATH.
- *
- * All entries are standalone binaries — `gh copilot` is intentionally
- * NOT here. lmctl's copilot transport spawns the standalone `copilot`
- * binary (see `src/cli/transports/acp.ts:58`), not the `gh` extension.
- *
- * Public-readable so test fixtures and audit/cache surfaces can read
- * the same canonical mapping. Mutating it at runtime is unsupported.
- */
-export declare const PROVIDER_BINARIES: Record<string, string>;
-export interface ProviderBinaryCheck {
-    /** Provider name as declared on a `_MEMBER_` line. */
-    provider: string;
-    /** Expected binary on PATH; `"<unknown>"` for unrecognized providers. */
-    binary: string;
-    /** True iff `<binary> --version` spawned and exited 0. */
-    found: boolean;
-    /** First line of stdout from `<binary> --version` on success, trimmed. */
-    version?: string;
-    /**
-     * When `!found`, an optional hint about what went wrong: `"not installed"`
-     * (spawn ENOENT) vs `"runs but failed"` (non-zero exit, dependency issue).
-     * `formatMissingBinaryError` uses this to emit a more actionable message.
-     */
-    failureMode?: "not installed" | "runs but failed";
-}
-/**
- * Per-provider one-line install hint shown in error messages from
- * `lint` and `autocode`. Kept terse — the goal is "what URL do I
- * paste into a browser," not a full installer guide.
- */
-export declare const PROVIDER_INSTALL_HINTS: Record<string, string>;
-/**
- * Injection seam — tests stub via `mock.module("node:child_process",
- * { spawnSync })`. The seam exists so the suite can simulate missing
- * binaries without depending on the runner's actual PATH (e.g. a CI
- * image with no provider CLIs installed would otherwise hard-fail
- * unrelated happy-path tests).
- *
- * The signature matches `childProcess.spawnSync`'s subset we care
- * about: status (null iff the spawn itself failed — ENOENT), plus
- * stdout + an error field we inspect for the `code` property.
- */
-export type SpawnSyncFn = (cmd: string, args: string[], options?: {
-    encoding?: string;
-    timeout?: number;
-}) => {
-    status: number | null;
-    stdout?: string | Buffer;
-    error?: {
-        code?: string;
-    } | Error;
-};
-export interface CheckOptions {
-    /** Test seam — defaults to `node:child_process.spawnSync`. */
-    spawnSync?: SpawnSyncFn;
-    /** Test seam — defaults to `process.platform`. Kept for API
-     *  back-compat; the new `<binary> --version` implementation is
-     *  cross-platform and no longer branches on it. */
-    platform?: NodeJS.Platform;
-}
-/**
- * Check each DISTINCT provider in `providers` against PATH. Order of
- * the returned array matches first-occurrence order in the input.
- * Duplicates collapse to one result. Unknown providers (not in
- * `PROVIDER_BINARIES`) yield `binary: "<unknown>", found: false`
- * rather than throwing — the caller formats the user-facing error.
- *
- * When `LMCTL_SKIP_BINARY_CHECK=1` is set in the environment, every
- * KNOWN provider is reported as found with `version: "(skipped)"`
- * and unknown providers are STILL surfaced as errors (a typo in a
- * teamfile shouldn't be hidden by a CI flag).
- */
-export declare function checkProviderBinaries(providers: Iterable<string>, options?: CheckOptions): ProviderBinaryCheck[];
-/**
- * Format a missing-binary error line for stderr/lint output. Keeps
- * the wording consistent across `lint` and `autocode` so users can
- * grep for `provider "<name>" binary` in CI.
- */
-export declare function formatMissingBinaryError(check: ProviderBinaryCheck): string;

package/dist/providers/bundle.d.ts

@@ -1,124 +0,0 @@
-/**
- * Bundle sessions (batch redesign, item 2 — Landing C1).
- *
- * A bundle session is ONE provider process serving many chat turns, built
- * for batch bundle mode (the default for multi-prompt runs): instead of
- * opens the session once, drives every prompt through it, and closes it
- * in a `finally`. This module holds the transport-agnostic contract; the
- * per-transport implementations live behind the adapters'
- * `ProviderAdapter.openSession` (ACP via transports/acp.ts, stream-json
- * via transports/stream-json.ts, codex via transports/codex-app-server.ts,
- * dsh via adapters/dsh-adapter.ts).
- *
- * ## Per-transport lifecycle contract (binding, from the v2 review)
- *
- * Every bundle transport MUST honor all of these; the ACP implementation
- * pins them in tests/providers/acp-bundle.test.ts:
- *
- *  1. **Per-turn completion boundary.** A turn ends at the transport's
- *     own result frame (ACP: the `session/prompt` response). Anything the
- *     provider emits after that boundary belongs to no turn and must
- *     never leak into a later turn's result.
- *  2. **Parser/state reset between turns.** The stateful output
- *     processor is retained across turns (provider-specific isolation,
- *     e.g. gemini's replay handling, keeps working) but reset per turn:
- *     no reply duplication, no stale deltas, no stale timers.
- *  3. **Cancellation.** Aborting a turn rejects THAT turn's promise and
- *     asks the provider to cancel (ACP: `session/cancel`); the session
- *     stays open and usable. Aborting is per turn — there is no
- *     bundle-level abort; use `close()`.
- *  4. **Hold-open policy.** The process is NOT closed between turns —
- *     the persistence IS the hold. `close()` runs the caller's
- *     `holdOpen` outstanding-work check ONCE before ending stdin, so the
- *     final turn's background dispatches get the same protection a
- *     one-shot turn would get.
- *  5. **Unexpected exit.** A mid-bundle process exit rejects the
- *     in-flight turn and every subsequent turn with an error naming the
- *     number of completed prompts, so the batch abort message carries
- *     the count.
- *  6. **Idempotent, bounded close.** `close()` may be called any number
- *     of times, including during an in-flight turn (which it cancels via
- *     process shutdown). It ends stdin, waits a bounded time for a
- *     natural exit, then escalates to SIGTERM/SIGKILL — it never hangs
- *     and never throws.
- *  7. **Identity.** Opening against an existing session id must verify
- *     the provider loaded THAT EXACT id before the first prompt is sent
- *     (no fallback to the requested id, no silent new session). Between
- *     turns the caller re-checks identity cheaply — for batch, the
- *     per-turn `expectedSession` check in chat-exec catches an external
- *     re-seed and aborts the bundle.
- */
-import type { PermissionMode } from "./yolo-contract.js";
-import type { HoldOpenOptions } from "./transports/hold-open.js";
-/** Per-turn options: streaming callbacks and this turn's abort signal. */
-export interface BundleTurnOptions {
-    /** Called for each text delta belonging to THIS turn. */
-    onDelta?: (text: string) => void;
-    /** Called for each raw transport event during THIS turn (progress classification). */
-    onEvent?: (event: Record<string, unknown>) => void;
-    /** Abort THIS turn (contract item 3); the session stays open. */
-    signal?: AbortSignal;
-}
-export interface BundleTurnResult {
-    text: string;
-    sessionId: string;
-    durationMs: number;
-    stopReason?: string;
-    /**
-     * Open-time provider configuration warnings (task #232 model/effort
-     * drops) are reported on the FIRST turn's result: in bundle mode the
-     * provider configuration is applied once at open, not per spawn.
-     */
-    warnings?: string[];
-    /**
-     * ACP bundle sessions only (see AcpOutputProcessorResult.sawActivity) --
-     * whether this turn saw any real agent activity, as opposed to a clean
-     * but empty completion. Omitted for non-ACP bundle implementations.
-     */
-    sawActivity?: boolean;
-}
-export interface BundleSession {
-    /** Provider key this session serves (e.g. "opencode"). */
-    readonly provider: string;
-    /** The verified session id (exact match to the requested id). */
-    readonly sessionId: string;
-    /** Successfully completed turns — the count bundle errors report. */
-    readonly completedTurns: number;
-    sendTurn(prompt: string, opts?: BundleTurnOptions): Promise<BundleTurnResult>;
-    /** Idempotent, bounded shutdown (contract item 6). Never throws. */
-    close(): Promise<void>;
-}
-/** Options for opening a bundle session (provider comes from the adapter). */
-export interface BundleSessionOpenOptions {
-    /** Native session id to resume — verified exactly (contract item 7). */
-    sessionId: string;
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    model?: string;
-    effort?: string;
-    alias?: string;
-    /** Role-based Lead signal (codex injects its MCP tool flags at spawn). */
-    isLead?: boolean;
-    permissionMode?: PermissionMode;
-    /** Override the spawned binary path (troubleshooting dev builds). */
-    progPath?: string;
-    /** Outstanding-work check run ONCE at close() before stdin ends. */
-    holdOpen?: HoldOpenOptions;
-    /** Shutdown cap for close() (tests / operator-driven shutdowns). */
-    closeTimeoutMs?: number;
-    /**
-     * stream-json only: override the session-file roots used by the bundle
-     * identity check (custom provider homes / tests). The claude adapter
-     * defaults it to its own provider home's projects dir.
-     */
-    sessionFileRoots?: string[];
-}
-/**
- * Providers bundle-capable BY DESIGN (item 2's verified support matrix):
- * persistent-process transports with a multi-turn protocol. All nine are
- * implemented (Landings C1+C2). agy/pi/lmplayer are one-shot print
- * transports and can NEVER bundle.
- */
-export declare const BUNDLE_CAPABLE_PROVIDERS: readonly string[];
-/** One-shot print transports — never bundle-capable; batch silently runs them per-turn. */
-export declare const BUNDLE_NEVER_CAPABLE_PROVIDERS: readonly string[];