@lmctl-ai/lmctl 0.1.342 → 0.2.3

package/dist/mcp/mediation.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,265 @@
+/**
+ * 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. */
+    status?: "ok" | "stalled";
+    /** 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

@@ -0,0 +1,17 @@
+import { BaseProviderAdapter } from "../base-adapter.js";
+import type { SeedOptions } 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[];
+    manualSeedHint(sessiondir: string): {
+        launchCommand: string;
+        postLaunchNote: string;
+        lsCommand: string;
+    };
+}
+export {};

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,89 @@
+/**
+ * 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 {};