@lmctl-ai/lmctl 0.2.38 → 0.2.40

package/dist/mcp/mediation.d.ts

@@ -1,128 +0,0 @@
-/**
- * Workflow-microservice mediation CORE (sub-problem 1, Phase 1).
- *
- * Transport-agnostic by construction: this module imports NO MCP/server
- * code and performs NO I/O of its own — it is a pure, synchronous snapshot
- * read over the canonical DB via the existing DAL surface (the SAME
- * surface the apicli routes call). The later transports wrap THIS:
- *   - B (pull tools, Phase 3): an `observe` MCP tool returns observe()'s view.
- *   - A (SDK push, Phase 4): a session loop polls observe() and emits
- *     notifications/elicitation.
- * Neither requires a core rewrite.
- *
- * Reuse map (design §3/§4):
- *   - `step` rows via `dal.listStepsForRun` (rows written once per
- *     state/node execution by `dal.insertStep`, src/db/index.ts) — the
- *     per-transition observable. NOT `session_event` (subordinate agent
- *     activity), NOT a parallel stream.
- *   - run lifecycle via `dal.getRun` → `run.current_state` /
- *     `run.terminal_state` / `run.paused_at` (written by
- *     `setRunCurrentState` / `setRunTerminalState` / the resume path).
- *
- * Deadlock class (#12/#30) stays designed-out: observe() is a stateless
- * read that returns immediately. It performs no self-call and never
- * blocks waiting for the run to terminate — callers poll it.
- */
-import type { Dal, RunRow, StepRow } from '../db/index.js';
-/** Minimal read surface the core needs — keeps it transport/Dal-agnostic. */
-export interface MediationReader {
-    getRun(id: number): RunRow | null;
-    listStepsForRun(run_id: number): StepRow[];
-    /**
-     * Job→run linkage for the invoke handle. `job.run_id` is set the moment
-     * the worker creates the run — atomically inside `dal.insertRun`
-     * (src/db/index.ts `setJobRun`), and was historically reinforced by the
-     * queue worker (moved to lmbee with the daemon, 2026-09-27). Null
-     * until then. EXISTING linkage — no new table/path.
-     */
-    getJob(id: number): {
-        run_id: number | null;
-    } | null;
-}
-export type RunStatus = 'not_found' | 'queued' | 'running' | 'paused' | 'terminal';
-/** One normalized node transition (1:1 with a `step` row). */
-export interface Transition {
-    step_id: number;
-    state_name: string;
-    outcome: string | null;
-    status_detail: string | null;
-    started_at: string;
-    ended_at: string | null;
-}
-export interface RunObservation {
-    /**
-     * The resolved run id, or `null` when observing by job handle and the
-     * worker has not created the run yet (transitional `status:'queued'`).
-     */
-    run_id: number | null;
-    status: RunStatus;
-    /** run.current_state — the node the run is at / next (may be `__paused__:<state>`). */
-    current_state: string | null;
-    /** run.terminal_state — non-null once the run has ended. */
-    terminal_state: string | null;
-    /** terminal_state !== null. The terminal signal — never dropped. */
-    terminal: boolean;
-    /** paused_at set, or current_state carries the engine `__paused__:` prefix. */
-    paused: boolean;
-    /** Step rows AFTER `sinceStepId`, ascending — the per-transition delta. */
-    transitions: Transition[];
-    /** Max step id observed (full set), or null if none — the observe cursor. */
-    latest_step_id: number | null;
-}
-/**
- * Snapshot the canonical state of one managed-workflow run as a normalized
- * transition view. `sinceStepId` (default 0) yields only transitions with
- * `step_id > sinceStepId` for incremental observation; `status` and
- * `latest_step_id` are always computed from the FULL step set so a cursored
- * caller still gets correct queued/running/terminal classification.
- *
- * Pure read, returns immediately — no held self-call, never blocks to
- * terminal (the #12/#30 deadlock class is structurally impossible here).
- */
-export declare function observe(reader: MediationReader, runId: number, sinceStepId?: number): RunObservation;
-/** Observe a managed run by run id OR by the invoke job handle. */
-export interface RunHandle {
-    run_id?: number;
-    /** The job id returned by invoke (POST /api/jobs). Resolved via getJob. */
-    job_id?: number;
-}
-/**
- * Consumable entrypoint for the invoke→observe loop. invoke returns a JOB
- * handle (the worker links the run LATER), so a client cannot observe by
- * run id from invoke's response. `observeHandle` resolves job→run using
- * the EXISTING `job.run_id` linkage (set by `insertRun`, src/db/index.ts:1240):
- *   - run_id given            → observe(run) directly.
- *   - job_id, run not linked  → coherent transitional snapshot
- *                               (run_id:null, status:'queued') — the client
- *                               keeps polling the SAME job handle, no extra
- *                               tool, no blocking (deadlock-class stays out).
- *   - job_id, run linked      → observe(job.run_id) — the real snapshot.
- * Uniform RunObservation shape throughout so the client's poll loop never
- * special-cases the job→run gap.
- */
-export declare function observeHandle(reader: MediationReader, h: RunHandle, sinceStepId?: number): RunObservation;
-export interface TransitInput {
-    /** The operator's answer text (route's `input`). */
-    input: string;
-    /** End the interactive session (route's `done`); default false. */
-    done?: boolean;
-    /** Target by run (active interactive_waiting_operator escalation for it)… */
-    run_id?: number;
-    /** …or by explicit attention id (takes precedence when both given). */
-    attention_id?: number;
-}
-export interface TransitResult {
-    ok: boolean;
-    /** Discovery/resume failure reason (mirrors the route's reason codes). */
-    reason?: 'no_active_escalation' | 'wrong_kind' | 'no_step' | 'already_acked' | 'not_found' | 'not_waiting_operator' | 'run_not_found';
-    /** Offending attention kind when reason === 'wrong_kind' (parity with app.ts:710). */
-    kind?: string;
-    attention_id?: number;
-    step_id?: number;
-    /** interactive_session.status after the existing resume (waiting_agent|done). */
-    session_status?: string;
-    acknowledged: boolean;
-    /** Fresh snapshot — proves the run transitioned off paused (resume cleared __paused__:). */
-    observation?: RunObservation;
-}
-export declare function transit(dal: Dal, t: TransitInput): TransitResult;

package/dist/mcp/path-warning.d.ts

@@ -1,7 +0,0 @@
-export interface McpExecutableWarningOptions {
-    env?: NodeJS.ProcessEnv;
-    warn?: (message: string) => void;
-}
-export declare function executableOnPath(command: string, env?: NodeJS.ProcessEnv): boolean;
-export declare function formatMissingMcpExecutableWarning(command: string, toolName: string): string;
-export declare function warnIfMcpExecutableMissing(command: string, toolName: string, options?: McpExecutableWarningOptions): void;

package/dist/mcp/server.d.ts

@@ -1,63 +0,0 @@
-import { type DispatchDeps } from './dispatch.js';
-export interface JsonRpcRequest {
-    jsonrpc: '2.0';
-    id?: number | string | null;
-    method: string;
-    params?: unknown;
-}
-export interface JsonRpcSuccess {
-    jsonrpc: '2.0';
-    id: number | string | null;
-    result: unknown;
-}
-export interface JsonRpcError {
-    jsonrpc: '2.0';
-    id: number | string | null;
-    error: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-}
-export type JsonRpcResponse = JsonRpcSuccess | JsonRpcError;
-export interface ServerIo {
-    /** Sink for outbound JSON-RPC frames (typically `process.stdout`). */
-    write(chunk: string): unknown;
-    /** Optional sink for human-readable stderr diagnostics. */
-    log?: (chunk: string) => void;
-}
-export interface ServerDeps {
-    io: ServerIo;
-    dispatch: DispatchDeps;
-}
-/**
- * Handle a single inbound message. Public for testability — the
- * `runServer` event loop just plumbs stdin/stdout into this.
- *
- * Returns:
- *   - `{kind:'response', message: ...}` for request→response handling
- *   - `{kind:'notification'}` when the inbound was a notification (id missing)
- *   - `{kind:'exit'}` when the inbound was an `exit` notification — the
- *     caller stops the loop. We pull this signal out as its own variant
- *     rather than e.g. throwing because the spec calls for a clean exit
- *     code (0 if `shutdown` was seen, 1 otherwise) and the cleanest way
- *     to encode that is bubbling the intent up.
- */
-export type HandleOutcome = {
-    kind: 'response';
-    message: JsonRpcResponse;
-} | {
-    kind: 'notification';
-} | {
-    kind: 'exit';
-};
-export declare function handleMessage(raw: JsonRpcRequest, deps: ServerDeps): Promise<HandleOutcome>;
-/**
- * Run the stdio event loop until EOF or `exit`. Accepts a readable
- * stream (default `process.stdin`) so tests can plug in a `PassThrough`.
- *
- * Returns the integer exit code:
- *   - 0 if `shutdown` was observed before exit (graceful)
- *   - 1 if exit / EOF arrived without `shutdown` (per LSP-derived MCP convention)
- */
-export declare function runServer(deps: ServerDeps, stdin: NodeJS.ReadableStream): Promise<number>;

package/dist/mcp/tools.d.ts

@@ -1,24 +0,0 @@
-/**
- * MCP tool catalog for AI-managed .lmctl teams.
- *
- * The managed workflow product is intentionally CLI-first for now; its
- * API is not exposed through MCP until that surface is explicitly designed.
- */
-export interface ToolDef {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: 'object';
-        properties: Record<string, {
-            type: string;
-            description?: string;
-            items?: unknown;
-        }>;
-        required?: readonly string[];
-        additionalProperties?: boolean;
-    };
-    local: true;
-}
-export declare const TOOLS: readonly ToolDef[];
-/** Total tool count for tests + tools/list assertions. */
-export declare const TOOL_COUNT: number;

package/dist/providers/adapter.d.ts

@@ -1,271 +0,0 @@
-/**
- * Provider Adapter — unified interface for all provider-specific behavior.
- *
- * Consolidates discovery, session lifecycle, agent turns, and injection
- * capabilities into one contract per provider. Replaces the scattered
- * provider switches across session-seed, user-config, transport manager,
- * and tail-cmd.
- */
-import type { ProviderName, SessionSummary, SessionDetail, WatchPathInfo } from "./types.js";
-/**
- * Normalized progress event from a provider turn. Each transport wrapper is
- * responsible for translating its native event stream into this shape so that
- * downstream consumers (idle-timer, stderr printer, future heartbeat) only
- * need to know one format.
- */
-export interface ProgressEvent {
-    /**
-     * Coarse classification of what the provider is doing.
-     *
-     * `api_retry` is special — it indicates the provider's HTTP transport
-     * is retrying upstream, which is the **absence** of progress, not the
-     * presence. The idle timer in withTimeouts must NOT reset on these
-     * events (task 63 finding 1). The heartbeat does observe them so the
-     * user can see the retry cadence in the running… tail.
-     */
-    kind: "tool_use" | "tool_result" | "thinking" | "text" | "system" | "api_retry" | "other";
-    /** Tool name when kind === "tool_use" / "tool_result" (e.g., "Bash"). */
-    tool?: string;
-    /** Short human-readable summary (e.g., "cargo build", "exit 0"). */
-    summary?: string;
-    /**
-     * Correlation id linking a tool_use to its matching tool_result. Set
-     * by classifiers when the underlying provider exposes a stable id
-     * (`tool_use_id` for claude, `item.id` for codex). Used by the
-     * progress printer to compute per-tool elapsed time on tool_result.
-     */
-    id?: string;
-    /**
-     * Wall-clock duration in ms, when the provider supplies it directly
-     * (codex sets this from `item.durationMs` on commandExecution
-     * completion). Optional. The printer prefers this over its own
-     * Map-based correlation when both are available.
-     */
-    elapsedMs?: number;
-    /**
-     * Normalized tool_result status: "ok" | "error" | "exit ${number}".
-     * Set by classifiers on tool_result events so the printer doesn't
-     * have to parse summary strings to decide success vs failure.
-     */
-    status?: string;
-    /**
-     * The original block / message dict from the provider's wire event,
-     * attached lossless for downstream consumers that want richer
-     * structure than the flat kind/tool/summary fields capture (e.g.
-     * `ThinkingBlock.signature`, `ServerToolUseBlock`,
-     * `RateLimitEvent`). Populated today by the claude stream-json
-     * classifier (per-block for content blocks, top-level message dict
-     * for `result`/`system`); codex/ACP classifiers do not populate it.
-     * Optional and advisory — classifiers MAY omit when the source is
-     * trivial (heartbeats, bare text deltas, synthesized api_retry).
-     */
-    raw?: Record<string, unknown>;
-}
-export interface TurnOptions {
-    sessionId: string;
-    cwd: string;
-    env?: NodeJS.ProcessEnv;
-    profile?: string;
-    requireResume?: boolean;
-    onDelta?: (text: string) => void;
-    /** Called for every classified progress event from the provider. */
-    onProgress?: (event: ProgressEvent) => void;
-    signal?: AbortSignal;
-    /** Idle timeout in milliseconds. Default: 8 hours. 0 = no timeout.
-     *  When the timer fires, the turn resolves with status: "stalled"
-     *  instead of killing the child process. */
-    timeoutMs?: number;
-    /** Called when the idle timer fires (before resolving as stalled).
-     *  Use for logging/debug output. */
-    onIdleWarning?: (elapsedMs: number) => void;
-    /** User config overrides — adapter checks this before using defaults. */
-    userConfig?: import("./config/types.js").UserConfig;
-    /**
-     * Override the spawned provider binary path. Used for troubleshooting
-     * with custom builds (e.g. `~/research/studyclaude/cli-dev` for a
-     * Claude Code dev build). When set, the transport spawns this exact
-     * path instead of looking up `claude` / `codex` / etc. on PATH.
-     * (Task 63 fix 3.)
-     */
-    progPath?: string;
-    /**
-     * Provider-specific model name (e.g. "claude-sonnet-4-6"). The
-     * transport maps this through each provider's supported surface:
-     * claude/gemini/qwen use `--model`, codex uses app-server
-     * `-c model="..."` plus RPC `model` overrides, opencode uses ACP
-     * `session/set_config_option`, and unsupported providers ignore
-     * with provider-specific diagnostics.
-     */
-    model?: string;
-    /** Provider-specific effort / variant override. Honored by OpenCode ACP; Kimi has no genuine per-turn effort override (see model-selection-lint.ts) so lint warns and ignores it there. */
-    effort?: string;
-    /**
-     * The teamfile alias of the member being spawned. Kept for diagnostics
-     * and old codex callers that only identify the literal "Lead" alias.
-     */
-    alias?: string;
-    /**
-     * Role-based Lead signal from teamfile resolution. Use this instead of
-     * alias text when Lead-only provider wiring is required; teams may name
-     * their leader something other than "Lead".
-     */
-    isLead?: boolean;
-    /**
-     * Permission mode for the turn — `"yolo"` (default) or `"plan"`.
-     *
-     *   - `"yolo"`: append the provider's permission-bypass flag (the
-     *     historical hardcoded behavior — `--dangerously-skip-permissions`
-     *     for claude, `--approval-mode yolo` for qwen, `-y` for gemini,
-     *     `--yolo` for copilot; codex JSON-RPC sandbox is
-     *     `danger-full-access`).
-     *   - `"plan"`: substitute the provider's plan-mode flag instead
-     *     (`--permission-mode plan` for claude, `--approval-mode plan`
-     *     for qwen/gemini; codex JSON-RPC sandbox is `read-only`).
-     *
-     * Default is `"yolo"` so calls that omit the field preserve the
-     * pre-existing argv/protocol shape exactly. See
-     * `src/providers/yolo-contract.ts` for the per-provider table.
-     *
-     * Caveat (gemini): plan mode filters `write_file` by workspace path
-     * only; an agent can still escape via `run_shell_command`. A tighter
-     * sandbox for plan mode is a follow-up.
-     */
-    permissionMode?: import("./yolo-contract.js").PermissionMode;
-    /**
-     * Defer the end-of-turn shutdown while the session being run still has
-     * outstanding dispatched work (live `agent_inflight` rows it is the
-     * SENDER of). Honored by the stream-json transport (claude/qwen), whose
-     * first-result stdin close is what orphans a session's
-     * `run_in_background` dispatches when the host process exits
-     * (BUG-chat-client-death-interrupts-receiver-live-session). Other
-     * transports currently ignore it: codex/ACP hold persistent server
-     * processes with different end-of-turn semantics and have not exhibited
-     * this failure mode.
-     */
-    holdOpen?: import("./transports/hold-open.js").HoldOpenOptions;
-    /**
-     * Caller-held bundle session (batch bundle mode): when set, the
-     * transport sends this turn through the ALREADY-OPEN provider process
-     * instead of spawning a new one. Per-turn spawn options (model, env,
-     * holdOpen, requireResume) were fixed at open and are ignored here;
-     * the per-turn `expectedSession` check upstream still verifies the
-     * returned sessionId. See src/providers/bundle.ts for the contract.
-     */
-    bundleSession?: import("./bundle.js").BundleSession;
-}
-export interface TurnResult {
-    text: string;
-    sessionId: string;
-    durationMs: number;
-    stopReason?: string;
-    numTurns?: number;
-    /** "ok" (default/omitted) = normal completion.
-     *  "stalled" = idle timeout fired — provider went silent for the
-     *  configured duration. The child process is still alive. The text
-     *  field contains whatever was produced before the stall.
-     *  "empty" = ACP transports only (see transport-wrappers.ts's
-     *  emptyTurnStatus): the provider's own protocol reported a normal
-     *  completion, but produced no text and no observed activity -- almost
-     *  always an upstream failure (rate limit, quota, auth) that the
-     *  provider's ACP layer swallowed instead of surfacing as an error.
-     *  Never set for non-ACP transports (stream-json, codex-app-server). */
-    status?: "ok" | "stalled" | "empty";
-    /** When status === "stalled": how long the provider was idle (ms). */
-    stalledAfterMs?: number;
-    /** Human-readable strings when this turn's provider silently dropped a
-     * declared model=/effort= (task #232). Omitted when nothing was dropped.
-     * Same convention as `SeedResult.warnings`. */
-    warnings?: string[];
-}
-export interface SeedResult {
-    success: boolean;
-    error?: string;
-    /** Non-fatal provider diagnostics that callers should surface to the operator. */
-    warnings?: string[];
-    /** Native session id when the provider reports it directly during seed. */
-    sessionId?: string;
-}
-export interface SeedOptions {
-    /** Provider-specific model name requested for the initial seed turn. */
-    model?: string;
-    /** Provider-specific effort / variant requested for the initial seed turn. */
-    effort?: string;
-    /** Optional provider seed prompt; defaults to the standard lmctl seed ACK prompt. */
-    prompt?: string;
-}
-export interface ForkResult {
-    success: boolean;
-    error?: string;
-    /** Native session ID of the forked session. */
-    sessionId?: string;
-    /** File path of the forked session (if applicable). */
-    filePath?: string;
-}
-export interface ProviderCapabilities {
-    canCreate: boolean;
-    canResumeInteractive: boolean;
-    canFork: boolean;
-    /** "automatic" = lmctl can fork end-to-end; "manual" = print instructions */
-    forkSupport: "automatic" | "manual";
-    canStructuredTurn: boolean;
-    canStreamDeltas: boolean;
-    canCancel: boolean;
-}
-export interface InjectionInfo {
-    /** How leader behavior can be shaped through public provider mechanisms. */
-    leaderMode: "none" | "prompt-append" | "skill-file" | "custom-tool";
-    /** Human-readable hint shown when creating a managed team with this leader. */
-    leaderSetupHint?: string;
-}
-/**
- * Per-provider instructions for the user to MANUALLY create a
- * session when `lmctl seed` auto-seed fails.
- *
- * Lmctl can't anticipate every cause of seed failure (workspace
- * trust, expired auth, sandbox restriction, version drift in flag
- * names) but the recovery is always the same shape: launch the
- * provider interactively, send lmctl's explicit seed instruction
- * to commit a waiting session file, then update the teamfile with
- * the new sessionid.
- *
- * Adapters override the default to inject provider-specific flags
- * (e.g. gemini's `--skip-trust` for the workspace-trust gate).
- */
-export interface ManualSeedHint {
-    /** Native command the user runs interactively to create a session.
-     *  Includes the `cd <sessiondir> && <binary> [flags]` shape. */
-    launchCommand: string;
-    /** One-line note on what to do INSIDE the launched session. */
-    postLaunchNote: string;
-    /** Filter to pass to `lmctl ls` for finding the freshly-created
-     *  session id. */
-    lsCommand: string;
-}
-export interface ProviderAdapter {
-    readonly name: ProviderName;
-    readonly capabilities: ProviderCapabilities;
-    readonly injection: InjectionInfo;
-    discover(): Promise<SessionSummary[]>;
-    load(sessionId: string): Promise<SessionDetail | null>;
-    resolvePath(sessionId: string): Promise<string | null>;
-    delete(sessionId: string): Promise<boolean>;
-    getWatchPaths?(): WatchPathInfo[];
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-    resumeCommand(sessionId: string, profile?: string): string;
-    startCommand(profile?: string): string;
-    /** Instructions for the user to manually seed this provider's
-     *  session in `sessiondir` when auto-seed fails. */
-    manualSeedHint(sessiondir: string): ManualSeedHint;
-    forkHint?(sessionId: string): string;
-    fork?(sessionId: string, tag: string): Promise<ForkResult>;
-    sendTurn(prompt: string, opts: TurnOptions): Promise<TurnResult>;
-    /**
-     * Open ONE provider process serving many turns (batch bundle
-     * mode). Present only on bundle-capable adapters — Landing C1
-     * implements the ACP providers (gemini/copilot/opencode/kimi/hermes);
-     * stream-json/codex/dsh follow. The lifecycle contract (per-turn
-     * boundary, cancellation, hold-open, unexpected exit, idempotent
-     * bounded close, session identity) is in `src/providers/bundle.ts`.
-     */
-    openSession?(opts: import("./bundle.js").BundleSessionOpenOptions): Promise<import("./bundle.js").BundleSession>;
-}

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

@@ -1,18 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions, SeedResult } from "../adapter.js";
-export declare function createAgyAdapter(opts?: {
-    agyDir?: string;
-}): AgyAdapter;
-declare class AgyAdapter extends BaseProviderAdapter {
-    constructor(opts?: {
-        agyDir?: string;
-    });
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-    manualSeedHint(sessiondir: string): {
-        launchCommand: string;
-        postLaunchNote: string;
-        lsCommand: string;
-    };
-}
-export {};

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

@@ -1,20 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createClaudeAdapter(opts?: {
-    claudeDir?: string;
-}): ClaudeAdapter;
-declare class ClaudeAdapter extends BaseProviderAdapter {
-    private readonly claudeDir;
-    constructor(opts?: {
-        claudeDir?: string;
-    });
-    /**
-     * Bundle support (batch redesign item 2): one stream-json process, many
-     * turns. The identity check's session-file root follows this adapter's
-     * provider home (custom claudeDir ⇒ custom projects dir).
-     */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-}
-export {};

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

@@ -1,22 +0,0 @@
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions, TurnOptions } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createCodexAdapter(opts?: {
-    codexDir?: string;
-    codeDir?: string;
-}): CodexAdapter;
-declare class CodexAdapter extends BaseProviderAdapter {
-    constructor(opts?: {
-        codexDir?: string;
-        codeDir?: string;
-    });
-    /**
-     * Bundle support (batch redesign item 2): one app-server process, many
-     * `turn/start`s on the strictly-resumed thread. The bare-member default
-     * model applies at open (same rule as turnOptsFor for one-shot turns).
-     */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    protected seedArgsFor(opts?: SeedOptions): string[];
-    protected turnOptsFor(opts: TurnOptions): TurnOptions;
-}
-export {};

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

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

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

@@ -1,89 +0,0 @@
-/**
- * dsh (DeepSeek Harness) provider adapter.
- *
- * dsh's headless profile is one-shot-only (no session resume — proven
- * three independent ways in `backlog/DESIGN-add-dsh-provider.md`). The
- * only real continuity path is the `web` profile's internal HTTP RPC
- * surface: `session.create` with a caller-supplied id, then repeated
- * `session.prompt` calls against that same id, genuinely carry context
- * forward (proven end-to-end). This adapter drives that RPC surface
- * through a managed sidecar (`dsh-sidecar.ts`) rather than spawning a new
- * `dsh` process per turn the way argv-templated providers (agy, claude,
- * codex, qwen) do — there is no equivalent one-shot-with-resume-flag
- * shape for dsh to model those on.
- */
-import { BaseProviderAdapter } from "../base-adapter.js";
-import type { SeedOptions, SeedResult } from "../adapter.js";
-import type { BundleSession, BundleSessionOpenOptions } from "../bundle.js";
-export declare function createDshAdapter(opts?: {
-    dshHome?: string;
-}): DshAdapter;
-interface DshRecord {
-    type?: string;
-    seq?: number;
-    time?: number;
-    data?: Record<string, unknown>;
-}
-declare class DshAdapter extends BaseProviderAdapter {
-    private readonly dshProvider;
-    constructor(opts?: {
-        dshHome?: string;
-    });
-    manualSeedHint(sessiondir: string): {
-        launchCommand: string;
-        postLaunchNote: string;
-        lsCommand: string;
-    };
-    /**
-     * Overridden entirely rather than relying on BaseProviderAdapter's
-     * default (spawn `binary` with `seedArgs` as a one-shot process) — dsh
-     * has no such mode with continuity. Generates the session id lmctl will
-     * use for every future turn, creates it via RPC, and sends the seed
-     * prompt through the exact same path a real turn uses.
-     */
-    seed(cwd: string, opts?: SeedOptions): Promise<SeedResult>;
-    private dshPromptTurn;
-    /**
-     * Bundle support (batch redesign item 2): hold the shared sidecar across
-     * turns — the per-turn `shutdownDshSidecar` in dshPromptTurn is deferred
-     * to close(). Turn completion stays the seq-scoped transcript poll
-     * (promptAndWait), which is per-turn safe by construction: each turn
-     * waits for a turn/end NEWER than the seq captured before its prompt.
-     *
-     * Cancellation is TERMINAL for dsh bundles (the adapter advertises
-     * canCancel: false — the RPC surface has no cancel verb): aborting a
-     * turn rejects it, shuts the sidecar down, and closes the bundle.
-     */
-    openSession(opts: BundleSessionOpenOptions): Promise<BundleSession>;
-    /** Send `prompt`, poll the session file until a NEW turn/end record
-     *  appears (by seq, so an earlier turn's completion can't be mistaken
-     *  for this one's), and return the newest assistant/message text. */
-    private promptAndWait;
-}
-interface TurnEndReason {
-    kind?: string;
-    error?: {
-        message?: string;
-        code?: string;
-    };
-}
-/**
- * dsh's own `turn/end` record carries a real, actionable error (e.g.
- * `{code:"MISSING_CREDENTIAL", message:"...store DEEPSEEK_API_KEY..."}`)
- * on a failed turn -- surface it instead of the bare reason kind, which
- * gave no hint the actual cause was a missing DEEPSEEK_API_KEY (real
- * incident: math.lmctl spent 4 seed attempts chasing a model-name red
- * herring before finding the real cause by reading raw session bytes).
- */
-declare function turnEndErrorMessage(reason: TurnEndReason | undefined): string;
-declare function maxTurnEndSeq(filePath: string): Promise<number>;
-declare function readRecordsSafe(filePath: string): Promise<DshRecord[]>;
-declare function assistantText(record: DshRecord): string;
-/** Test seam for the pure record helpers (F1/F4 regression tests). */
-export declare const _internals: {
-    assistantText: typeof assistantText;
-    readRecordsSafe: typeof readRecordsSafe;
-    maxTurnEndSeq: typeof maxTurnEndSeq;
-    turnEndErrorMessage: typeof turnEndErrorMessage;
-};
-export {};