@snappedly-tools/shipyard 0.8.0 → 0.9.1

package/dist/index.d.ts

@@ -1,559 +1,9 @@
-import { S as SessionTransferHandle, a as SandboxProvider, B as BranchStrategy, E as ExecResult, b as MergeToHeadBranchStrategy, N as NamedBranchStrategy } from './MountConfig-BHnKnA4h.js';
-export { c as InteractiveExecOptions, d as IsolatedCreateOptions, e as IsolatedSandboxHandle, I as IsolatedSandboxProvider, f as IsolatedSandboxProviderConfig, M as MountConfig, g as createIsolatedSandboxProvider } from './MountConfig-BHnKnA4h.js';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-/** Reasoning efforts accepted by the Codex CLI. */
-declare const CODEX_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh", "max"];
-type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORTS)[number];
-/** A model identifier plus the reasoning policy used for that model role. */
-interface CodexModelConfig {
-    readonly model: string;
-    readonly effort: CodexReasoningEffort;
-}
-declare const CODEX_MODELS: {
-    readonly routine: {
-        readonly model: string;
-        readonly effort: "low" | "medium" | "high" | "xhigh" | "max";
-    };
-    readonly strong: {
-        readonly model: string;
-        readonly effort: "low" | "medium" | "high" | "xhigh" | "max";
-    };
-};
-
-type ParsedStreamEvent = {
-    type: "text";
-    text: string;
-} | {
-    type: "result";
-    result: string;
-} | {
-    type: "tool_call";
-    name: string;
-    args: string;
-} | {
-    type: "session_id";
-    sessionId: string;
-} | {
-    type: "usage";
-    usage: IterationUsage;
-};
-/** Options passed to buildPrintCommand and buildInteractiveArgs. */
-interface AgentCommandOptions {
-    readonly prompt: string;
-    readonly dangerouslySkipPermissions: boolean;
-    /** Tools the controlled phase is permitted to invoke. */
-    readonly toolAllowlist?: readonly string[];
-    /** When set, the agent should resume the given session ID instead of starting fresh. */
-    readonly resumeSession?: string;
-    /**
-     * When true alongside `resumeSession`, the agent should fork the session
-     * instead of mutating it — Claude's `--fork-session`, Codex's
-     * `codex exec fork`. The parent session JSONL is left intact and the agent
-     * writes a new session under a fresh id.
-     */
-    readonly forkSession?: boolean;
-}
-/** Return type of buildPrintCommand — command string plus optional stdin content.
- *  When `stdin` is set, the sandbox pipes it to the child process's stdin
- *  instead of inlining the prompt in argv, avoiding the Linux 128 KB per-arg limit. */
-interface PrintCommand {
-    readonly command: string;
-    readonly stdin?: string;
-}
-/** Per-iteration token usage snapshot extracted from the agent session. */
-interface IterationUsage {
-    readonly inputTokens: number;
-    readonly cacheCreationInputTokens: number;
-    readonly cacheReadInputTokens: number;
-    readonly outputTokens: number;
-}
-interface AgentSessionStorage {
-    /** Transfer a session JSONL from the sandbox into the host store. */
-    captureToHost(args: {
-        hostCwd: string;
-        sandboxCwd: string;
-        sessionId: string;
-        handle: SessionTransferHandle;
-    }): Promise<void>;
-    /** Transfer a session JSONL from the host store into the sandbox. */
-    resumeIntoSandbox(args: {
-        hostCwd: string;
-        sandboxCwd: string;
-        sessionId: string;
-        handle: SessionTransferHandle;
-    }): Promise<void>;
-    /** Read a captured session JSONL from the host store. Returns undefined when absent. */
-    readHostSession(cwd: string, sessionId: string): Promise<string | undefined>;
-    /** Whether a session with the given id exists in the host store keyed on cwd. */
-    existsOnHost(cwd: string, sessionId: string): Promise<boolean>;
-    /** Absolute host path where a session would be stored (for not-found error messages). */
-    hostSessionFilePath(cwd: string, sessionId: string): string | undefined;
-}
-interface AgentProvider {
-    readonly name: string;
-    /** Environment variables injected by this agent provider. Merged at launch time with env resolver and sandbox provider env. */
-    readonly env: Record<string, string>;
-    /** Set only when this provider enforces `AgentCommandOptions.toolAllowlist`. */
-    readonly supportsToolAllowlist?: boolean;
-    /** When true, session capture is enabled for this provider. Default: true for file-backed providers. */
-    readonly captureSessions: boolean;
-    /** Provider-owned storage and transfer behavior for resumable agent sessions. */
-    readonly sessionStorage?: AgentSessionStorage;
-    buildPrintCommand(options: AgentCommandOptions): PrintCommand;
-    buildInteractiveArgs?(options: AgentCommandOptions): string[];
-    parseStreamLine(line: string): ParsedStreamEvent[];
-    /** Parse token usage from the captured session JSONL content. Only implemented by Claude Code. */
-    parseSessionUsage?(content: string): IterationUsage | undefined;
-}
-/** Options for the codex agent provider. */
-interface CodexOptions {
-    /** Set to `null` to use the provider default instead of a configured role effort. */
-    readonly effort?: CodexReasoningEffort | null;
-    /** Environment variables injected by this agent provider. */
-    readonly env?: Record<string, string>;
-    /** When false, session capture is disabled. Default: true. */
-    readonly captureSessions?: boolean;
-    /** Override Codex session directories for tests or non-standard installs. */
-    readonly sessionStorage?: {
-        readonly hostSessionsDir?: string;
-        readonly sandboxSessionsDir?: string;
-    };
-    /**
-     * Maps to Codex's `approvals_reviewer` config key (set via
-     * `-c approvals_reviewer="<value>"`). When set to `"auto_review"`, the
-     * provider swaps the default `--dangerously-bypass-approvals-and-sandbox`
-     * for an interactive approval policy (`-a on-request`) and Codex's most
-     * permissive sandbox (`-s danger-full-access`) — auto-review needs
-     * something to review, and the safety boundary is the reviewer agent
-     * rather than the filesystem sandbox.
-     */
-    readonly approvalsReviewer?: "user" | "auto_review";
-}
-declare const codex: (model: string | CodexModelConfig, options?: CodexOptions) => AgentProvider & {
-    readonly sessionStorage: AgentSessionStorage;
-};
-interface ClaudeCodeOptions {
-    /** Set to `null` to leave effort selection to the provider. */
-    readonly effort?: "low" | "medium" | "high" | "xhigh" | "max" | null;
-    /** Environment variables injected by this agent provider. */
-    readonly env?: Record<string, string>;
-    /** When false, session capture is disabled. Default: true. */
-    readonly captureSessions?: boolean;
-    /** Override Claude session directories for tests or non-standard installs. */
-    readonly sessionStorage?: {
-        readonly hostProjectsDir?: string;
-        readonly sandboxProjectsDir?: string;
-    };
-    /**
-     * Maps directly to Claude's `--permission-mode` flag. When set, replaces the
-     * default `--dangerously-skip-permissions` Shipyard passes on AFK runs —
-     * the two flags are mutually exclusive on Claude's CLI. Use `"auto"` for
-     * AI-mediated per-tool approve/deny on unsandboxed host runs.
-     */
-    readonly permissionMode?: "default" | "acceptEdits" | "plan" | "auto" | "dontAsk" | "bypassPermissions";
-}
-declare const claudeCode: (model: string, options?: ClaudeCodeOptions) => AgentProvider & {
-    readonly sessionStorage: AgentSessionStorage;
-};
-
-/**
- * A single event in the agent's output stream, surfaced to callers of `run()`
- * so they can forward it to their own observability system.
- *
- * Emitted only in log-to-file mode when an `onAgentStreamEvent` callback is
- * provided via `logging`. See `run()`.
- *
- * The `"raw"` variant carries every stdout line the agent emits, verbatim and
- * before parsing — including lines that the provider's stream parser would
- * otherwise drop (e.g. tool-use blocks for unrecognised tools). Intended for
- * debugging when the typed `"text"` / `"toolCall"` events don't surface
- * enough detail.
- */
-type AgentStreamEvent = {
-    readonly type: "text";
-    readonly message: string;
-    readonly iteration: number;
-    readonly timestamp: Date;
-} | {
-    readonly type: "toolCall";
-    readonly name: string;
-    readonly formattedArgs: string;
-    readonly iteration: number;
-    readonly timestamp: Date;
-} | {
-    readonly type: "raw";
-    readonly line: string;
-    readonly iteration: number;
-    readonly timestamp: Date;
-};
-
-type SandboxHooks = {
-    readonly host?: {
-        readonly onWorktreeReady?: ReadonlyArray<{
-            readonly command: string;
-            readonly timeoutMs?: number;
-        }>;
-        readonly onSandboxReady?: ReadonlyArray<{
-            readonly command: string;
-            readonly timeoutMs?: number;
-        }>;
-    };
-    readonly sandbox?: {
-        readonly onSandboxReady?: ReadonlyArray<{
-            readonly command: string;
-            readonly sudo?: boolean;
-            readonly timeoutMs?: number;
-        }>;
-    };
-};
-
-/** Per-iteration result carrying an optional session ID. */
-interface IterationResult {
-    /** Agent session ID extracted from the provider stream, when available. */
-    readonly sessionId?: string;
-    /** Absolute host path to the captured session record, when capture is enabled. */
-    readonly sessionFilePath?: string;
-    /** Token usage snapshot from the last assistant message in the session, or undefined when capture is disabled or provider does not support usage parsing. */
-    readonly usage?: IterationUsage;
-}
-
-/**
- * A map of named values used for prompt argument substitution.
- * Each key corresponds to a `{{KEY}}` placeholder in the prompt; the value
- * replaces it before the prompt is passed to the agent.
- */
-type PromptArgs = Record<string, string | number | boolean>;
-
-/** Branded output definition for `Output.object({ tag, schema })`. */
-interface OutputObjectDefinition<T> {
-    readonly _tag: "object";
-    readonly tag: string;
-    readonly schema: StandardSchemaV1<unknown, T>;
-    /**
-     * Maximum number of additional attempts after the first if structured output
-     * extraction or validation fails. Each retry resumes the failed run's agent
-     * session and feeds back a token-efficient description of the error so the
-     * agent can re-emit a corrected tag. Default: `0` (no retries).
-     *
-     * Retries require the agent provider to support session resumption (i.e.
-     * `provider.sessionStorage` is populated — Codex or Claude Code). `run()`
-     * fails at entry with a clear error when retries are requested but the
-     * provider cannot resume.
-     */
-    readonly maxRetries?: number;
-}
-/** Branded output definition for `Output.string({ tag })`. */
-interface OutputStringDefinition {
-    readonly _tag: "string";
-    readonly tag: string;
-    /**
-     * Maximum number of additional attempts after the first if structured output
-     * extraction fails. Each retry resumes the failed run's agent session and
-     * feeds back a token-efficient description of the error so the agent can
-     * re-emit a corrected tag. Default: `0` (no retries).
-     *
-     * Retries require the agent provider to support session resumption (i.e.
-     * `provider.sessionStorage` is populated — Codex or Claude Code). `run()`
-     * fails at entry with a clear error when retries are requested but the
-     * provider cannot resume.
-     */
-    readonly maxRetries?: number;
-}
-/** Union of all output definition shapes accepted by `run()`. */
-type OutputDefinition = OutputObjectDefinition<any> | OutputStringDefinition;
-/**
- * Helpers for declaring structured output on `run()`.
- *
- * ```ts
- * import { Output, run } from "@snappedly-tools/shipyard";
- * import { z } from "zod";
- *
- * const result = await run({
- *   output: Output.object({ tag: "result", schema: z.object({ answer: z.number() }) }),
- *   // ...
- * });
- * console.log(result.output.answer); // typed as number
- * ```
- */
-declare const Output: {
-    /**
-     * Declare an object-typed structured output extracted from an XML tag in
-     * the agent's stdout. The tag contents are JSON-parsed (with fence-aware
-     * unwrapping) and validated against the provided Standard Schema validator.
-     *
-     * Set `maxRetries` to have `run()` automatically resume the failed session
-     * and ask the agent to re-emit corrected output when extraction or
-     * validation fails. Default: `0` (no retries).
-     */
-    readonly object: <Schema extends StandardSchemaV1>(opts: {
-        tag: string;
-        schema: Schema;
-        maxRetries?: number;
-    }) => OutputObjectDefinition<StandardSchemaV1.InferOutput<Schema>>;
-    /**
-     * Declare a string-typed structured output extracted from an XML tag in
-     * the agent's stdout. The tag contents are whitespace-trimmed and returned
-     * as a plain string — no JSON parsing, no schema validation.
-     *
-     * Set `maxRetries` to have `run()` automatically resume the failed session
-     * and ask the agent to re-emit corrected output when extraction fails.
-     * Default: `0` (no retries).
-     */
-    readonly string: (opts: {
-        tag: string;
-        maxRetries?: number;
-    }) => OutputStringDefinition;
-};
-interface StructuredOutputErrorOptions {
-    readonly tag: string;
-    readonly rawMatched: string | undefined;
-    readonly cause?: unknown;
-    readonly commits: {
-        sha: string;
-    }[];
-    readonly branch: string;
-    readonly preservedWorktreePath?: string;
-    readonly sessionId?: string;
-    readonly sessionFilePath?: string;
-}
-/**
- * Thrown by `run()` when structured output extraction or validation fails.
- *
- * Possible failure modes:
- * - The configured XML tag was not found in stdout (`rawMatched` is `undefined`).
- * - The tag contents failed `JSON.parse` (`cause` carries the parse error).
- * - The parsed JSON failed schema validation (`cause` carries the Standard Schema issues).
- *
- * The error carries `commits`, `branch`, and optionally `preservedWorktreePath`
- * so callers can decide recovery without losing the run's side effects.
- *
- * It also carries `sessionId` (and `sessionFilePath` when the session was
- * captured to the host) of the iteration that produced the bad output, so a
- * caller can resume that same session and ask the agent to re-emit corrected
- * output:
- *
- * ```ts
- * try {
- *   return await run({ ...opts, output });
- * } catch (e) {
- *   if (e instanceof StructuredOutputError && e.sessionId) {
- *     return await run({
- *       ...opts,
- *       output,
- *       resumeSession: e.sessionId,
- *       prompt: feedback(e),
- *     });
- *   }
- *   throw e;
- * }
- * ```
- */
-declare class StructuredOutputError extends Error {
-    readonly tag: string;
-    readonly rawMatched: string | undefined;
-    readonly cause: unknown;
-    readonly commits: {
-        sha: string;
-    }[];
-    readonly branch: string;
-    readonly preservedWorktreePath?: string;
-    /** Session ID of the iteration that produced the bad output, when available. */
-    readonly sessionId?: string;
-    /** Host path to the captured session JSONL, when the session was captured. */
-    readonly sessionFilePath?: string;
-    constructor(message: string, options: StructuredOutputErrorOptions);
-}
-
-/**
- * Controls where Shipyard writes iteration progress and agent output.
- * Use `"file"` (log-to-file mode) to write to a log file on disk, or
- * `"stdout"` (terminal mode) to render an interactive UI in the terminal.
- */
-type LoggingOption = 
-/** Write progress and agent output to a log file at the given path (log-to-file mode). */
-{
-    readonly type: "file";
-    readonly path: string;
-    /**
-     * Optional callback invoked for each agent stream event (text chunk,
-     * tool call, or raw stdout line) in addition to being written to the
-     * log file. Intended for forwarding the agent's output stream to
-     * external observability systems. Errors thrown by the callback are
-     * swallowed.
-     */
-    readonly onAgentStreamEvent?: (event: AgentStreamEvent) => void;
-    /**
-     * When `true`, every raw stdout line the agent emits is appended
-     * verbatim to the same log file at `path`, in real time. Includes
-     * lines the provider's stream parser would otherwise drop (e.g.
-     * tool-use blocks for unrecognised tools). Intended for debugging
-     * stuck or unexpected agent behavior — note that the raw JSON is
-     * interleaved with the human-readable log output. Default: `false`.
-     */
-    readonly verbose?: boolean;
-}
-/** Render progress and agent output as an interactive UI in the terminal (terminal mode). */
- | {
-    readonly type: "stdout";
-    /**
-     * When `true`, every raw stdout line the agent emits is written
-     * verbatim to `process.stdout`, in real time. Includes lines the
-     * provider's stream parser would otherwise drop. Intended for
-     * debugging stuck or unexpected agent behavior. Note: the raw output
-     * is interleaved with the interactive terminal UI. Default: `false`.
-     */
-    readonly verbose?: boolean;
-};
-/** Override default timeouts for built-in lifecycle steps. Unset keys keep their defaults. */
-interface Timeouts {
-    /** Timeout (ms) for copying selected paths into a worktree or Docker sandbox. Default: 60_000. */
-    readonly copyToWorktreeMs?: number;
-    /** Timeout (ms) for each in-sandbox git setup command (safe.directory, user.name/email, branch discovery). Default: 10_000. */
-    readonly gitSetupMs?: number;
-    /** Timeout (ms) for collecting the commits produced during the run. Default: 30_000. */
-    readonly commitCollectionMs?: number;
-    /** Timeout (ms) for merging the temp branch back to the host branch (merge-to-head strategy). Default: 30_000. */
-    readonly mergeToHostMs?: number;
-}
-interface RunOptions<A extends AgentProvider = AgentProvider> {
-    /** Agent provider to use (e.g. codex(CODEX_MODELS.routine)) */
-    readonly agent: A;
-    /** Sandbox provider (e.g. docker({ imageName: "shipyard:myrepo" })). */
-    readonly sandbox: SandboxProvider;
-    /**
-     * Host repo directory. Replaces `process.cwd()` as the anchor for
-     * `.shipyard/worktrees/`, `.shipyard/.env`, `.shipyard/logs/YYYY-MM-DD/`,
-     * `.shipyard/patches/`, and git operations.
-     *
-     * - Relative paths are resolved against `process.cwd()`.
-     * - Absolute paths are used as-is.
-     * - Defaults to `process.cwd()` when omitted.
-     */
-    readonly cwd?: string;
-    /** Inline prompt string (mutually exclusive with promptFile) */
-    readonly prompt?: string;
-    /**
-     * Path to a prompt file (mutually exclusive with prompt).
-     *
-     * **Note:** `promptFile` is always resolved against `process.cwd()`, not
-     * against the `cwd` option. If you set a custom `cwd`, pass an absolute
-     * `promptFile` to avoid ambiguity.
-     */
-    readonly promptFile?: string;
-    /** Maximum iterations to run (default: 1) */
-    readonly maxIterations?: number;
-    /** Lifecycle hooks grouped by execution location (host or sandbox). */
-    readonly hooks?: SandboxHooks;
-    /** Key-value map for {{KEY}} placeholder substitution in prompts */
-    readonly promptArgs?: PromptArgs;
-    /** Logging mode (default: { type: 'file' } with auto-generated path under .shipyard/logs/YYYY-MM-DD/) */
-    readonly logging?: LoggingOption;
-    /** Substring(s) the agent emits to stop the iteration loop early. Matched via `includes` against agent output. (default: `"<promise>COMPLETE</promise>"`) */
-    readonly completionSignal?: string | string[];
-    /** Idle timeout in seconds. If the agent produces no output for this long, it fails. Default: 600 (10 minutes) */
-    readonly idleTimeoutSeconds?: number;
-    /**
-     * Grace window in seconds after a completion signal is observed in the
-     * agent's output. The agent process is expected to exit shortly after
-     * emitting the signal; if it does not (typically because a spawned child —
-     * a `gh`/git subprocess or long-lived MCP server — keeps stdout open),
-     * Shipyard force-completes the iteration with a warning. Resets on every
-     * subsequent output line so trailing data (token-usage events, terminal
-     * `result` events, structured-output tags) is still captured. Independent
-     * of `idleTimeoutSeconds`. Default: 60.
-     */
-    readonly completionTimeoutSeconds?: number;
-    /** Optional name for the run, shown as a prefix in log output */
-    readonly name?: string;
-    /** Paths relative to the host repo root to copy into Docker after Git sync. */
-    readonly copyToWorktree?: string[];
-    /** Tools the provider must enforce for this controlled phase. */
-    readonly toolAllowlist?: readonly string[];
-    /** Branch strategy; defaults to merge-to-head. */
-    readonly branchStrategy?: BranchStrategy;
-    /** Resume a prior agent session by ID. The session record must exist on the host. Incompatible with maxIterations > 1. */
-    readonly resumeSession?: string;
-    /**
-     * An `AbortSignal` that cancels the run when aborted.
-     *
-     * - If `signal.aborted` is already `true` at entry, `run()` rejects
-     *   immediately without doing any setup work.
-     * - Aborting mid-iteration kills the in-flight agent subprocess.
-     * - Phase boundaries (between iterations) also check the signal.
-     * - The rejected promise surfaces `signal.reason` via
-     *   `signal.throwIfAborted()` — no Shipyard-specific wrapping.
-     * - The worktree is preserved on disk after abort (error-path behavior).
-     */
-    readonly signal?: AbortSignal;
-    /** Override default timeouts for built-in lifecycle steps. Unset keys keep their defaults. */
-    readonly timeouts?: Timeouts;
-    /**
-     * Structured output definition. When provided, the agent's stdout is
-     * scanned for the configured XML tag after the iteration completes, and the
-     * result is parsed/validated and returned on `RunResult.output`.
-     *
-     * Use `Output.object({ tag, schema })` for JSON+schema or
-     * `Output.string({ tag })` for raw string extraction.
-     *
-     * Constraints:
-     * - `maxIterations` must be `1` (the default).
-     * - The resolved prompt must contain the configured opening tag literal.
-     *
-     * See ADR 0010 for design rationale.
-     */
-    readonly output?: OutputDefinition;
-}
-
-type ResumeRunResultOptions = Omit<RunOptions, "agent" | "sandbox" | "prompt" | "promptFile" | "resumeSession" | "forkSession" | "maxIterations">;
-interface RunResult {
-    /** Per-iteration results (use `iterations.length` for the count). */
-    readonly iterations: IterationResult[];
-    /** The matched completion signal string, or undefined if no signal fired before the iteration limit. */
-    readonly completionSignal?: string;
-    /** Combined stdout output from all agent iterations. */
-    readonly stdout: string;
-    /** List of commits made by the agent during the run, each identified by its SHA. */
-    readonly commits: {
-        sha: string;
-    }[];
-    /** The branch name the agent worked on inside the sandbox. */
-    readonly branch: string;
-    /** Path to the log file, if logging was drained to a file. */
-    readonly logFilePath?: string;
-    /** Host path to the preserved worktree, set when the run succeeded but the worktree had uncommitted changes. */
-    readonly preservedWorktreePath?: string;
-    /** Continue the last captured agent session for exactly one iteration.
-     *  Present only when the provider supports resume (`sessionStorage` populated). */
-    readonly resume?: (prompt: string, options?: ResumeRunResultOptions) => Promise<RunResult>;
-    /**
-     * Fork the last captured agent session for exactly one iteration: the
-     * parent session JSONL is left intact and the child run gets its own
-     * session id, enabling fan-out patterns where multiple children diverge
-     * from a single parent. Present only when the provider supports resume
-     * (`sessionStorage` populated).
-     *
-     * Sessions only: fork isolates the agent session, not the branch or
-     * sandbox. Safe concurrent fan-out (`Promise.all([r.fork(a), r.fork(b)])`)
-     * requires the caller to give each fork a distinct `branch` — `head` and
-     * `merge-to-head` are not safe for concurrent forks. See ADR 0018.
-     */
-    readonly fork?: (prompt: string, options?: ResumeRunResultOptions) => Promise<RunResult>;
-}
-/** Overload: with `Output.object`, returns `RunResult` with typed `output: T`. */
-declare function run<T, A extends AgentProvider>(options: RunOptions<A> & {
-    output: OutputObjectDefinition<T>;
-}): Promise<RunResult & {
-    output: T;
-}>;
-/** Overload: with `Output.string`, returns `RunResult` with `output: string`. */
-declare function run<A extends AgentProvider>(options: RunOptions<A> & {
-    output: OutputStringDefinition;
-}): Promise<RunResult & {
-    output: string;
-}>;
-/** Overload: without `output`, returns the standard `RunResult`. */
-declare function run<A extends AgentProvider>(options: RunOptions<A>): Promise<RunResult>;
+import { A as AgentProvider, S as SandboxHooks, P as PromptArgs, T as Timeouts, L as LoggingOption, I as IterationResult, a as Sandbox, C as CloseResult } from './createSandbox-DmbnWAZv.js';
+export { b as AgentCommandOptions, c as AgentStreamEvent, d as CODEX_MODELS, e as CODEX_REASONING_EFFORTS, f as ClaudeCodeOptions, g as CodexModelConfig, h as CodexOptions, i as CodexReasoningEffort, j as CreateSandboxOptions, k as IterationUsage, O as Output, l as OutputDefinition, m as OutputObjectDefinition, n as OutputStringDefinition, o as PrintCommand, R as ResumeSandboxRunResultOptions, p as RunOptions, q as RunResult, r as SandboxExecOptions, s as SandboxInteractiveOptions, t as SandboxInteractiveResult, u as SandboxRunOptions, v as SandboxRunResult, w as StructuredOutputError, x as claudeCode, y as codex, z as createSandbox, B as run } from './createSandbox-DmbnWAZv.js';
+import { S as SandboxProvider, B as BranchStrategy, M as MergeToHeadBranchStrategy, N as NamedBranchStrategy } from './SandboxProvider-oUAwYlWm.js';
+export { E as ExecResult, a as InteractiveExecOptions, b as IsolatedCreateOptions, c as IsolatedSandboxHandle, I as IsolatedSandboxProvider, d as IsolatedSandboxProviderConfig, e as createIsolatedSandboxProvider } from './SandboxProvider-oUAwYlWm.js';
+export { M as MountConfig } from './MountConfig-K5ILnfht.js';
+import '@standard-schema/spec';
 
 interface InteractiveOptions {
     /** Agent provider to use (e.g. codex(CODEX_MODELS.routine)) */
@@ -623,188 +73,6 @@ interface InteractiveResult {
  */
 declare const interactive: (options: InteractiveOptions) => Promise<InteractiveResult>;
 
-interface CreateSandboxOptions {
-    /** Explicit branch for the worktree (required). */
-    readonly branch: string;
-    /**
-     * Ref to fork from when `branch` does not yet exist. Ignored when the branch
-     * already exists. Defaults to `HEAD`.
-     */
-    readonly baseBranch?: string;
-    /** Sandbox provider (e.g. docker({ imageName: "shipyard:myrepo" })). */
-    readonly sandbox: SandboxProvider;
-    /**
-     * Host repo directory. Replaces `process.cwd()` as the anchor for
-     * `.shipyard/worktrees/`, `.shipyard/.env`, and git operations.
-     *
-     * - Relative paths are resolved against `process.cwd()`.
-     * - Absolute paths are used as-is.
-     * - Defaults to `process.cwd()` when omitted.
-     */
-    readonly cwd?: string;
-    /** Lifecycle hooks grouped by execution location (host or sandbox). */
-    readonly hooks?: SandboxHooks;
-    /** Paths relative to the host repo root to copy into Docker after Git sync. */
-    readonly copyToWorktree?: string[];
-    /** Override default timeouts for built-in lifecycle steps. Unset keys keep their defaults. */
-    readonly timeouts?: Timeouts;
-}
-/**
- * Options accepted by `SandboxRunResult.resume()` / `.fork()`. Mirrors
- * `ResumeRunResultOptions` in `run.ts` — drops the fields owned by the
- * captured run (prompt, iteration count, resumeSession/forkSession bookkeeping).
- *
- * Defined as the base interface that `SandboxRunOptions` extends — the
- * interface-extends shape is cheaper for the TS checker than
- * `Omit<SandboxRunOptions, ...>` (which forces a mapped-type computation
- * on every reference).
- */
-interface ResumeSandboxRunResultOptions {
-    /** Key-value map for {{KEY}} placeholder substitution in prompts. */
-    readonly promptArgs?: PromptArgs;
-    /** Substring(s) the agent emits to stop the iteration loop early. */
-    readonly completionSignal?: string | string[];
-    /** Idle timeout in seconds. Default: 600. */
-    readonly idleTimeoutSeconds?: number;
-    /** Grace window in seconds after a completion signal is observed but the agent process has not exited. See ADR 0019. Default: 60. */
-    readonly completionTimeoutSeconds?: number;
-    /** Display name for this run. */
-    readonly name?: string;
-    /** Tools the provider must enforce for this controlled phase. */
-    readonly toolAllowlist?: readonly string[];
-    /** Logging mode. */
-    readonly logging?: LoggingOption;
-    /**
-     * An `AbortSignal` that cancels the run when aborted.
-     *
-     * - Pre-aborted signal rejects immediately without setup.
-     * - Mid-iteration abort kills the in-flight agent subprocess.
-     * - The rejected promise surfaces `signal.reason` verbatim.
-     * - The `Sandbox` handle remains usable after abort — call `.run()` again
-     *   with a fresh signal, or `.close()` to tear down.
-     */
-    readonly signal?: AbortSignal;
-}
-interface SandboxRunOptions extends ResumeSandboxRunResultOptions {
-    /** Agent provider to use (e.g. codex(CODEX_MODELS.routine)). */
-    readonly agent: AgentProvider;
-    /** Inline prompt string (mutually exclusive with promptFile). */
-    readonly prompt?: string;
-    /** Path to a prompt file (mutually exclusive with prompt). */
-    readonly promptFile?: string;
-    /** Maximum iterations to run (default: 1). */
-    readonly maxIterations?: number;
-    /** Resume a prior agent session by id. The session JSONL must exist on the host (captured by a prior `sandbox.run()`). Incompatible with `maxIterations > 1`. */
-    readonly resumeSession?: string;
-}
-interface SandboxRunResult {
-    /** Per-iteration results (use `iterations.length` for the count). */
-    readonly iterations: IterationResult[];
-    /** The matched completion signal string, or undefined if none fired. */
-    readonly completionSignal?: string;
-    /** Combined stdout output from all agent iterations. */
-    readonly stdout: string;
-    /** List of commits made by the agent during the run. */
-    readonly commits: {
-        sha: string;
-    }[];
-    /** Path to the log file, if logging was drained to a file. */
-    readonly logFilePath?: string;
-    /**
-     * Continue the last captured agent session for exactly one iteration inside
-     * the same long-lived sandbox. Present only when the provider supports
-     * resume (`sessionStorage` populated) and a session id was captured.
-     */
-    readonly resume?: (prompt: string, options?: ResumeSandboxRunResultOptions) => Promise<SandboxRunResult>;
-    /**
-     * Fork the last captured agent session for exactly one iteration inside the
-     * same long-lived sandbox: the parent session JSONL is left intact and the
-     * child run gets its own session id. Present only when the provider
-     * supports resume (`sessionStorage` populated) and a session id was
-     * captured. See ADR 0018 for fork semantics.
-     */
-    readonly fork?: (prompt: string, options?: ResumeSandboxRunResultOptions) => Promise<SandboxRunResult>;
-}
-interface SandboxInteractiveOptions {
-    /** Agent provider to use (e.g. codex(CODEX_MODELS.routine)). */
-    readonly agent: AgentProvider;
-    /** Inline prompt string (mutually exclusive with promptFile). */
-    readonly prompt?: string;
-    /** Path to a prompt file (mutually exclusive with prompt). */
-    readonly promptFile?: string;
-    /** Key-value map for {{KEY}} placeholder substitution in prompts. */
-    readonly promptArgs?: PromptArgs;
-    /** Display name for this interactive session. */
-    readonly name?: string;
-    /**
-     * An `AbortSignal` that cancels the interactive session when aborted.
-     *
-     * - Pre-aborted signal rejects immediately without setup.
-     * - The rejected promise surfaces `signal.reason` verbatim.
-     * - The `Sandbox` handle remains usable after abort.
-     */
-    readonly signal?: AbortSignal;
-}
-interface SandboxInteractiveResult {
-    /** List of commits made during the interactive session. */
-    readonly commits: {
-        sha: string;
-    }[];
-    /** Exit code of the interactive process. */
-    readonly exitCode: number;
-}
-interface CloseResult {
-    /** Host path to the preserved worktree, set when the worktree had uncommitted changes. */
-    readonly preservedWorktreePath?: string;
-}
-interface Sandbox {
-    /** The branch the worktree is on. */
-    readonly branch: string;
-    /** Host path to the worktree. */
-    readonly worktreePath: string;
-    /** Invoke an agent inside the existing sandbox. */
-    run(options: SandboxRunOptions): Promise<SandboxRunResult>;
-    /** Launch an interactive agent session inside the existing sandbox. */
-    interactive(options: SandboxInteractiveOptions): Promise<SandboxInteractiveResult>;
-    /**
-     * Execute a command inside the existing sandbox.
-     *
-     * `cwd` defaults to the sandbox repo path (same default `interactive()`
-     * uses), so callers get the same working directory across providers. Pass
-     * `cwd` to override.
-     *
-     * Returns the full `ExecResult` — non-zero `exitCode` is surfaced, not
-     * thrown. Callers that want strict semantics should check `result.exitCode`
-     * themselves (matching the contract of `SessionTransferHandle.exec`).
-     */
-    exec(command: string, options?: SandboxExecOptions): Promise<ExecResult>;
-    /** Tear down the sandbox and worktree. */
-    close(): Promise<CloseResult>;
-    /** Auto teardown via `await using`. */
-    [Symbol.asyncDispose](): Promise<void>;
-}
-/** Options accepted by `Sandbox.exec()`. Mirrors the provider handle's `exec` options. */
-interface SandboxExecOptions {
-    /** Per-line stdout callback for streaming output. */
-    readonly onLine?: (line: string) => void;
-    /** Working directory for the command. Defaults to the sandbox repo path. */
-    readonly cwd?: string;
-    /** Run the command with sudo, when the provider supports it. */
-    readonly sudo?: boolean;
-    /** Stdin payload — piped to the child process and then closed. Avoids the Linux 128 KB per-arg limit. */
-    readonly stdin?: string;
-    /** Abort the command when the surrounding operation is cancelled. */
-    readonly signal?: AbortSignal;
-    /** Reject/terminate the command after this many combined output bytes. */
-    readonly maxOutputBytes?: number;
-}
-/**
- * Eagerly creates a git worktree on the provided explicit branch and starts
- * a Docker sandbox with a synced Git workspace. Returns a Sandbox handle that
- * can be reused across multiple `run()` calls.
- */
-declare const createSandbox: (options: CreateSandboxOptions) => Promise<Sandbox>;
-
 /** Branch strategies valid for createWorktree — head is excluded. */
 type WorktreeBranchStrategy = MergeToHeadBranchStrategy | NamedBranchStrategy;
 interface CreateWorktreeOptions {
@@ -1025,1799 +293,4 @@ interface CwdError extends Error {
 /** The provided `cwd` path does not exist or is not a directory. */
 declare const CwdError: CwdErrorConstructor;
 
-declare const WORKFLOW_CONTRACT_VERSION: 1;
-type WorkItemKind = "planning-spec" | "executable-issue" | "pr-repair";
-type RiskLevel = "low" | "medium" | "high" | "critical";
-type WorkRisk = RiskLevel | "unknown";
-type WorkScope = "small" | "substantial" | "unknown";
-type WorkflowPhase = "triage" | "implementation" | "checking" | "review" | "repair" | "handoff" | "merge" | "release-verification";
-type LifecycleState = "queued" | "waiting-info" | "authorized" | "implementing" | "checking" | "reviewing" | "repairing" | "human-review" | "merged" | "release-verifying" | "completed" | "failed" | "blocked" | "cancelled";
-type PhaseOutcome = "completed" | "needs-info" | "blocked" | "failed" | "cancelled";
-type CheckStatus = "passed" | "failed" | "incomplete" | "blocked" | "unknown";
-type FindingSeverity = "info" | "low" | "medium" | "high" | "critical";
-type ReviewAxis = "standards" | "spec" | "interface";
-type FindingDisposition = "open" | "fixed" | "rejected" | "accepted" | "deferred";
-interface WorkIdentity {
-    readonly repository: string;
-    readonly itemId: string;
-    readonly kind: WorkItemKind;
-}
-interface SourceReference {
-    readonly provider: "github" | "slack" | "manual";
-    readonly repository: string;
-    readonly itemId: string;
-    readonly url?: string;
-    /** Original content is retained durably but must not be echoed to an unauthorized destination. */
-    readonly originalBody: string;
-    readonly author?: string;
-}
-interface RevisionReference {
-    readonly branch: string;
-    readonly sha: string;
-}
-interface Authorization {
-    readonly status: "pending" | "approved" | "withdrawn";
-    readonly actor?: string;
-    readonly actorRole?: "maintainer" | "owner" | "policy";
-    readonly approvedAt?: string;
-}
-interface VerificationPlan {
-    readonly checks: readonly string[];
-    readonly artifacts: readonly string[];
-}
-interface WorkBrief {
-    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
-    readonly id: string;
-    readonly revision: number;
-    readonly hash: string;
-    readonly identity: WorkIdentity;
-    readonly source: SourceReference;
-    readonly problem: string;
-    readonly evidence: readonly string[];
-    readonly acceptanceCriteria: readonly string[];
-    readonly exclusions: readonly string[];
-    readonly risk: WorkRisk;
-    readonly scope?: WorkScope;
-    readonly verification: VerificationPlan;
-    readonly unresolvedQuestions: readonly string[];
-    readonly authorization: Authorization;
-    readonly base: RevisionReference;
-    readonly policyRevision: string;
-    readonly skillRevision: string;
-    readonly createdAt: string;
-}
-interface CheckCommand {
-    readonly name: string;
-    readonly command: string;
-    readonly required: boolean;
-}
-interface PhaseBudget {
-    readonly maxAttempts: number;
-    readonly timeoutSeconds: number;
-}
-type AgentRole = "routine" | "strong";
-interface AgentModelRoles {
-    readonly routine: string;
-    readonly strong: string;
-}
-type WorkerPolicy = {
-    readonly provider: string;
-    readonly sandbox: string;
-    readonly skillRevision: string;
-} & ({
-    readonly model: string;
-    readonly models?: never;
-} | {
-    readonly model?: never;
-    readonly models: AgentModelRoles;
-});
-interface AgentSelection {
-    readonly provider: string;
-    readonly model: string;
-    readonly role: AgentRole;
-}
-interface RepositoryPolicy {
-    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
-    readonly repository: string;
-    readonly revision: string;
-    readonly baseBranch: string;
-    readonly issueClosure: "merge-and-ci" | "staging-verification" | "production-verification";
-    readonly authorization: {
-        readonly required: boolean;
-        readonly allowedActors: readonly ("maintainer" | "owner" | "policy")[];
-        readonly autoStartRisk: readonly RiskLevel[];
-    };
-    readonly worker: WorkerPolicy;
-    readonly checks: readonly CheckCommand[];
-    readonly phaseBudgets: Readonly<Record<WorkflowPhase, PhaseBudget>>;
-    readonly repairBudget: {
-        readonly maxBatches: number;
-        readonly maxFollowUps: number;
-    };
-}
-/** Whether a brief carries an authorization accepted by this repository policy. */
-declare const isAuthorizationAllowed: (brief: Pick<WorkBrief, "authorization">, policy: Pick<RepositoryPolicy, "authorization">) => boolean;
-interface CheckEvidence {
-    readonly name: string;
-    readonly command: string;
-    readonly status: CheckStatus;
-    readonly summary: string;
-    /** Candidate identity for checks that are used as a lifecycle gate. */
-    readonly baseSha?: string;
-    readonly headSha?: string;
-    readonly briefHash?: string;
-    readonly startedAt?: string;
-    readonly completedAt?: string;
-    readonly exitCode?: number;
-    readonly artifactRefs?: readonly string[];
-}
-interface Finding {
-    readonly id: string;
-    readonly severity: FindingSeverity;
-    readonly axis: ReviewAxis;
-    readonly disposition: FindingDisposition;
-    readonly title: string;
-    readonly evidence: string;
-    readonly location?: string;
-    readonly requirement?: string;
-    readonly verification?: string;
-}
-interface ReviewEvidence {
-    readonly outcome: "passed" | "actionable-findings" | "incomplete" | "blocked" | "failed";
-    readonly axes: readonly ReviewAxis[];
-    readonly findings: readonly Finding[];
-    readonly headSha: string;
-    readonly baseSha?: string;
-    readonly briefHash: string;
-}
-interface PhaseResult {
-    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
-    readonly assignmentId: string;
-    readonly phase: WorkflowPhase;
-    readonly outcome: PhaseOutcome;
-    readonly identity: WorkIdentity;
-    /** Brief revision executed by this phase. */
-    readonly briefHash: string;
-    readonly base?: RevisionReference;
-    readonly head?: RevisionReference;
-    readonly summary: string;
-    readonly evidence: readonly string[];
-    readonly checks: readonly CheckEvidence[];
-    readonly commits: readonly string[];
-    readonly artifacts: readonly string[];
-    readonly questions: readonly string[];
-    readonly findings: readonly Finding[];
-    /** Review axes explicitly completed, including axes with no findings. */
-    readonly reviewAxes?: readonly ReviewAxis[];
-    readonly completedAt: string;
-}
-interface Assignment {
-    readonly contractVersion: typeof WORKFLOW_CONTRACT_VERSION;
-    readonly id: string;
-    readonly phase: WorkflowPhase;
-    readonly attempt: number;
-    readonly identity: WorkIdentity;
-    readonly briefId: string;
-    readonly briefRevision: number;
-    readonly briefHash: string;
-    readonly policyRevision: string;
-    readonly skillRevision: string;
-    /** Missing only on assignments persisted before role model selection shipped. */
-    readonly agentSelection?: AgentSelection;
-    readonly base: RevisionReference;
-    readonly head?: RevisionReference;
-    readonly createdAt: string;
-}
-interface TransitionContext {
-    readonly kind: WorkItemKind;
-    readonly authorization: Authorization["status"];
-    readonly checks?: readonly CheckEvidence[];
-    /** Required check names from the repository policy. */
-    readonly requiredCheckNames?: readonly string[];
-    /** Exact candidate identity required for lifecycle-gating check evidence. */
-    readonly checkCandidate?: {
-        readonly baseSha: string;
-        readonly headSha: string;
-        readonly briefHash: string;
-    };
-    readonly review?: ReviewEvidence;
-    readonly currentHeadSha?: string;
-    readonly assignedHeadSha?: string;
-}
-declare class ContractValidationError extends Error {
-    readonly issues: readonly string[];
-    constructor(message: string, issues?: readonly string[]);
-}
-type CreateWorkBriefInput = Omit<WorkBrief, "contractVersion" | "id" | "revision" | "hash"> & {
-    readonly id?: string;
-    readonly revision?: number;
-    /** Accepted for callers carrying a previously materialized brief; always recomputed. */
-    readonly hash?: string;
-    readonly contractVersion?: typeof WORKFLOW_CONTRACT_VERSION;
-};
-declare const createWorkBrief: (input: CreateWorkBriefInput) => WorkBrief;
-declare const parseWorkBrief: (value: unknown) => WorkBrief;
-type CreateRepositoryPolicyInput = Omit<RepositoryPolicy, "contractVersion">;
-declare const parseRepositoryPolicy: (value: unknown) => RepositoryPolicy;
-declare const createRepositoryPolicy: (input: CreateRepositoryPolicyInput) => RepositoryPolicy;
-declare const resolveAgentSelection: (policy: Pick<RepositoryPolicy, "worker">, phase: WorkflowPhase, risk?: WorkRisk, scope?: WorkScope) => AgentSelection;
-declare const parseCheckEvidence: (value: unknown) => CheckEvidence;
-declare const requireTransition: (from: LifecycleState, to: LifecycleState, context: TransitionContext) => void;
-interface CreateAssignmentInput {
-    readonly id: string;
-    readonly phase: WorkflowPhase;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly attempt: number;
-    readonly head?: RevisionReference;
-    readonly createdAt: string;
-}
-declare const createAssignment: (input: CreateAssignmentInput) => Assignment;
-declare const parsePhaseResult: (value: unknown) => PhaseResult;
-
-type JobControl = "active" | "paused" | "cancelled" | "superseded";
-type EventStatus = "received" | "accepted" | "ignored";
-type EventIgnoreReason = "out-of-order" | "closed-item" | "withdrawn-authorization" | "repository-stopped" | "invalid-policy";
-type DispatchStatus = "pending" | "claimed" | "started" | "completed" | "failed" | "cancelled";
-type EffectStatus = "pending" | "claimed" | "succeeded" | "uncertain" | "failed" | "cancelled";
-interface WorkKey {
-    readonly repository: string;
-    readonly itemId: string;
-    readonly briefRevision: number;
-    readonly phase: WorkflowPhase;
-    readonly relevantRevision: string;
-}
-interface WorkflowEventInput {
-    readonly deliveryId: string;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly phase: WorkflowPhase;
-    readonly relevantRevision: string;
-    readonly observedAt: string;
-    /** A closed source item invalidates queued and active work. */
-    readonly sourceState?: "open" | "closed";
-    readonly payload?: unknown;
-}
-interface StoredEvent extends WorkflowEventInput {
-    readonly id: string;
-    readonly key: WorkKey;
-    readonly status: EventStatus;
-    readonly ignoreReason?: EventIgnoreReason;
-    readonly jobId?: string;
-    readonly receivedAt: string;
-}
-interface RepairBudgetUsage {
-    readonly repairBatches: number;
-    readonly followUps: number;
-}
-interface WorkflowJob {
-    readonly id: string;
-    readonly key: WorkKey;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly state: LifecycleState;
-    readonly control: JobControl;
-    readonly phaseAttempts: Readonly<Record<WorkflowPhase, number>>;
-    readonly repairBatches: number;
-    readonly followUps: number;
-    readonly infrastructureRetries: number;
-    readonly infrastructureRetryLimit: number;
-    readonly assignments: readonly Assignment[];
-    readonly phaseResults: readonly PhaseResult[];
-    readonly activeAssignmentId?: string;
-    readonly latestObservedAt: string;
-    readonly createdAt: string;
-    readonly updatedAt: string;
-    readonly version: number;
-}
-interface DispatchIntent {
-    readonly id: string;
-    readonly dedupeKey: string;
-    readonly key: WorkKey;
-    readonly jobId: string;
-    readonly status: DispatchStatus;
-    readonly assignment?: Assignment;
-    readonly workerId?: string;
-    readonly claimedAt?: number;
-    readonly claimExpiresAt?: number;
-    readonly error?: string;
-    readonly createdAt: string;
-    readonly updatedAt: string;
-}
-interface EffectIntent {
-    readonly id: string;
-    readonly jobId: string;
-    readonly kind: string;
-    readonly marker: string;
-    readonly payload?: unknown;
-    readonly status: EffectStatus;
-    readonly externalRef?: unknown;
-    readonly workerId?: string;
-    readonly fencingToken?: number;
-    readonly claimedAt?: number;
-    readonly claimExpiresAt?: number;
-    readonly error?: string;
-    readonly createdAt: string;
-    readonly updatedAt: string;
-}
-interface BranchLease {
-    readonly leaseId: string;
-    readonly resourceKey: string;
-    readonly repository: string;
-    readonly branch: string;
-    readonly jobId: string;
-    readonly workerId: string;
-    readonly fencingToken: number;
-    readonly acquiredAt: number;
-    readonly heartbeatAt: number;
-    readonly expiresAt: number;
-}
-interface RepositoryControl {
-    readonly repository: string;
-    readonly stopped: boolean;
-    readonly reason?: string;
-    readonly updatedAt: string;
-}
-interface CoordinatorStorageTransaction {
-    insertEventIfAbsent(event: StoredEvent): Promise<{
-        readonly event: StoredEvent;
-        readonly inserted: boolean;
-    }>;
-    saveEvent(event: StoredEvent): Promise<void>;
-    /** Serialize intake for an identity even before its first job row exists. */
-    lockWorkIdentity(identity: WorkIdentity): Promise<void>;
-    getJob(jobId: string): Promise<WorkflowJob | undefined>;
-    findJobByKey(key: WorkKey, briefHash: string): Promise<WorkflowJob | undefined>;
-    findCurrentJob(identity: WorkIdentity): Promise<WorkflowJob | undefined>;
-    insertJob(job: WorkflowJob): Promise<void>;
-    saveJob(job: WorkflowJob): Promise<void>;
-    findDispatchByDedupeKey(dedupeKey: string): Promise<DispatchIntent | undefined>;
-    findDispatchByAssignmentId(assignmentId: string): Promise<DispatchIntent | undefined>;
-    findPendingDispatch(repository: string, nowMilliseconds: number, selector?: {
-        readonly jobId?: string;
-        readonly dispatchId?: string;
-    }): Promise<DispatchIntent | undefined>;
-    insertDispatchIfAbsent(dispatch: DispatchIntent): Promise<{
-        readonly dispatch: DispatchIntent;
-        readonly inserted: boolean;
-    }>;
-    saveDispatch(dispatch: DispatchIntent): Promise<void>;
-    findEffect(jobId: string, kind: string, marker: string): Promise<EffectIntent | undefined>;
-    insertEffectIfAbsent(effect: EffectIntent): Promise<{
-        readonly effect: EffectIntent;
-        readonly inserted: boolean;
-    }>;
-    saveEffect(effect: EffectIntent): Promise<void>;
-    getLease(repository: string, branch: string): Promise<BranchLease | undefined>;
-    /** Serialize lease acquisition even when no lease row exists yet. */
-    lockLeaseResource(repository: string, branch: string): Promise<void>;
-    saveLease(lease: BranchLease): Promise<void>;
-    findLeasesForJob(jobId: string): Promise<readonly BranchLease[]>;
-    findLeasesForRepository(repository: string): Promise<readonly BranchLease[]>;
-    getRepositoryControl(repository: string): Promise<RepositoryControl | undefined>;
-    saveRepositoryControl(control: RepositoryControl): Promise<void>;
-}
-interface CoordinatorStorage {
-    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
-}
-interface CoordinatorClock {
-    now(): string;
-    nowMilliseconds(): number;
-}
-interface WorkflowCoordinatorOptions {
-    readonly storage: CoordinatorStorage;
-    readonly clock?: CoordinatorClock;
-    readonly idFactory?: (prefix: string) => string;
-    readonly infrastructureRetryLimit?: number;
-    readonly dispatchClaimTtlMs?: number;
-    readonly effectClaimTtlMs?: number;
-}
-interface DispatchRequest {
-    readonly repository: string;
-    readonly workerId: string;
-    /** Restrict dispatch to a known job/intent when a workflow runner is resuming. */
-    readonly jobId?: string;
-    readonly dispatchId?: string;
-}
-type DispatchBlockReason = "repository-stopped" | "job-paused" | "job-cancelled" | "job-superseded" | "authorization-withdrawn" | "authorization-pending" | "invalid-policy" | "semantic-budget-exhausted" | "infrastructure-retries-exhausted" | "invalid-transition";
-interface IngestResult {
-    readonly disposition: "accepted" | "duplicate" | "out-of-order" | "ignored";
-    readonly event: StoredEvent;
-    readonly job?: WorkflowJob;
-    readonly dispatch?: DispatchIntent;
-    readonly reason?: EventIgnoreReason;
-}
-interface DispatchResult {
-    readonly status: "dispatched" | "none" | "blocked";
-    readonly dispatch?: DispatchIntent;
-    readonly assignment?: Assignment;
-    readonly job?: WorkflowJob;
-    readonly reason?: DispatchBlockReason;
-}
-interface AcquireBranchLeaseInput {
-    readonly repository: string;
-    readonly branch: string;
-    readonly jobId: string;
-    readonly workerId: string;
-    readonly ttlMs: number;
-}
-interface SubmitPhaseResultInput {
-    readonly jobId: string;
-    readonly result: PhaseResult;
-    /** Every non-duplicate result must be fenced by the worker's active lease. */
-    readonly lease: BranchLease;
-}
-interface SchedulePhaseInput {
-    readonly jobId: string;
-    readonly phase: WorkflowPhase;
-    readonly relevantRevision: string;
-    readonly head?: {
-        readonly branch: string;
-        readonly sha: string;
-    };
-}
-interface SchedulePhaseResult {
-    readonly status: "scheduled" | "duplicate" | "blocked";
-    readonly job: WorkflowJob;
-    readonly dispatch?: DispatchIntent;
-    readonly reason?: string;
-}
-interface PhaseResultSubmission {
-    readonly job: WorkflowJob;
-    readonly duplicate: boolean;
-    readonly transitioned: boolean;
-}
-interface InfrastructureFailureInput {
-    readonly jobId: string;
-    readonly assignmentId: string;
-    readonly error: string;
-}
-interface InfrastructureRetryResult {
-    readonly status: "retry-scheduled" | "exhausted" | "not-retryable";
-    readonly job: WorkflowJob;
-    readonly dispatch?: DispatchIntent;
-}
-interface RepairRequestResult {
-    readonly status: "scheduled" | "blocked" | "not-allowed";
-    readonly job: WorkflowJob;
-    readonly dispatch?: DispatchIntent;
-    readonly reason?: string;
-}
-interface EffectOperationContext {
-    readonly effect: EffectIntent;
-    readonly fencingToken: number;
-}
-interface PublishEffectInput<T> {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    /** Optional resource binding for effects that operate on a branch. */
-    readonly branch?: string;
-    /** Optional resource binding for effects that target the workflow item. */
-    readonly itemId?: string;
-    /** Optional candidate binding for effects that publish a commit head. */
-    readonly headSha?: string;
-    readonly kind: string;
-    readonly marker: string;
-    readonly payload?: unknown;
-    readonly reconcile?: (context: EffectOperationContext) => Promise<T | undefined>;
-    readonly publish: (context: EffectOperationContext) => Promise<T>;
-}
-interface EffectExecution<T> {
-    readonly disposition: "published" | "reconciled" | "already-succeeded" | "in-flight";
-    readonly effect: EffectIntent;
-    readonly externalRef?: T;
-}
-
-/**
- * Deterministic storage for coordinator tests. Each transaction runs against
- * an isolated draft and commits atomically when the callback succeeds.
- */
-declare class InMemoryCoordinatorStorage implements CoordinatorStorage {
-    private state;
-    private transactionTail;
-    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
-}
-
-/** Minimal query surface implemented by `pg`, Neon, and compatible clients. */
-interface PostgresQueryResult<Row extends Record<string, unknown> = Record<string, unknown>> {
-    readonly rows: readonly Row[];
-    readonly rowCount?: number | null;
-}
-interface PostgresQueryClient {
-    query<Row extends Record<string, unknown> = Record<string, unknown>>(text: string, values?: readonly unknown[]): Promise<PostgresQueryResult<Row>>;
-}
-interface PostgresConnection extends PostgresQueryClient {
-    release?: () => void;
-}
-interface PostgresCoordinatorStorageOptions {
-    /** A connected client or a pool with a transaction-scoped `connect()` method. */
-    readonly client: PostgresQueryClient & {
-        readonly connect?: () => Promise<PostgresConnection>;
-    };
-}
-/** PostgreSQL-backed implementation; schema installation remains an operator concern. */
-declare class PostgresCoordinatorStorage implements CoordinatorStorage {
-    private readonly client;
-    constructor(options: PostgresCoordinatorStorageOptions);
-    transaction<T>(operation: (transaction: CoordinatorStorageTransaction) => Promise<T>): Promise<T>;
-}
-
-declare class LeaseLostError extends Error {
-    constructor(message?: string);
-}
-declare class LeaseBusyError extends Error {
-    constructor(message: string);
-}
-declare class WorkflowCoordinator {
-    private readonly storage;
-    private readonly clock;
-    private readonly idFactory;
-    private readonly infrastructureRetryLimit;
-    private readonly dispatchClaimTtlMs;
-    private readonly effectClaimTtlMs;
-    constructor(options: WorkflowCoordinatorOptions);
-    getJob(jobId: string): Promise<WorkflowJob | undefined>;
-    getCurrentJob(identity: WorkIdentity): Promise<WorkflowJob | undefined>;
-    getRepositoryControl(repository: string): Promise<RepositoryControl | undefined>;
-    ingest(input: WorkflowEventInput): Promise<IngestResult>;
-    dispatchNext(request: DispatchRequest): Promise<DispatchResult>;
-    private latestHeadForRevision;
-    private dispatchBlockReason;
-    acquireBranchLease(input: AcquireBranchLeaseInput): Promise<BranchLease>;
-    heartbeatBranchLease(lease: BranchLease): Promise<BranchLease>;
-    private assertLease;
-    publishEffect<T>(input: PublishEffectInput<T>): Promise<EffectExecution<T>>;
-    private assertPublicationAllowed;
-    private finishEffect;
-    recordPhaseResult(input: SubmitPhaseResultInput): Promise<{
-        job: WorkflowJob;
-        duplicate: boolean;
-        transitioned: boolean;
-    }>;
-    recordInfrastructureFailure(input: InfrastructureFailureInput): Promise<InfrastructureRetryResult>;
-    setRepositoryStop(input: {
-        readonly repository: string;
-        readonly stopped: boolean;
-        readonly reason?: string;
-    }): Promise<RepositoryControl>;
-    pauseJob(jobId: string, reason?: string): Promise<WorkflowJob>;
-    cancelJob(jobId: string, reason?: string): Promise<WorkflowJob>;
-    supersedeJob(jobId: string, reason?: string): Promise<WorkflowJob>;
-    resumeJob(jobId: string): Promise<WorkflowJob>;
-    private updateJobControl;
-    schedulePhase(input: SchedulePhaseInput): Promise<SchedulePhaseResult>;
-    scheduleRepair(input: {
-        readonly jobId: string;
-        readonly brief: WorkBrief;
-        readonly policy: RepositoryPolicy;
-        readonly followUp?: boolean;
-        readonly relevantRevision?: string;
-    }): Promise<RepairRequestResult>;
-    private cancelStoredJob;
-}
-
-interface TrustedPhaseInputs {
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly skill: {
-        readonly revision: string;
-        readonly content: string;
-    };
-}
-interface UntrustedPhaseInputs {
-    readonly sourceText: string;
-    readonly repositoryContent: readonly string[];
-}
-interface PhaseControls {
-    readonly toolAllowlist: readonly string[];
-    readonly credentialAllowlist: readonly string[];
-    readonly timeoutSeconds: number;
-    readonly maxIterations: number;
-}
-interface CredentialResolver {
-    resolve(name: string): Promise<string | undefined>;
-}
-declare class CredentialNotAllowedError extends Error {
-    constructor(name: string);
-}
-declare class CredentialUnavailableError extends Error {
-    constructor(name: string);
-}
-interface PhaseCredentials {
-    get(name: string): Promise<string>;
-}
-interface PhaseCheckout {
-    readonly branch: string;
-    readonly candidate?: RevisionReference;
-    readonly immutable: boolean;
-}
-interface PhaseEngineRequest {
-    readonly assignment: Assignment;
-    readonly agentSelection: AgentSelection;
-    readonly trusted: TrustedPhaseInputs;
-    readonly untrusted: UntrustedPhaseInputs;
-    readonly controls: PhaseControls;
-    readonly credentials: PhaseCredentials;
-    readonly signal: AbortSignal;
-    readonly checkout: PhaseCheckout;
-    readonly output?: OutputDefinition;
-}
-interface PhaseArtifact {
-    readonly name: string;
-    readonly kind: "stdout" | "stderr" | "patch" | "log" | "worktree" | "other";
-    readonly content: string;
-}
-interface ArtifactStore {
-    save(artifact: PhaseArtifact): Promise<void>;
-}
-interface InMemoryArtifactStore extends ArtifactStore {
-    readonly artifacts: PhaseArtifact[];
-}
-declare const createInMemoryArtifactStore: () => InMemoryArtifactStore;
-interface PhaseReport {
-    readonly summary: string;
-    readonly evidence: readonly string[];
-    readonly checks: readonly CheckEvidence[];
-    readonly commits: readonly string[];
-    readonly artifacts: readonly string[];
-    readonly questions: readonly string[];
-    readonly findings: readonly Finding[];
-    readonly reviewAxes?: readonly ReviewAxis[];
-}
-interface PhaseEngineResponse {
-    readonly stdout: string;
-    readonly stderr?: string;
-    readonly completionSignal?: string;
-    /** Kept for adapters that already validate output; executePhase revalidates stdout. */
-    readonly structuredOutput?: unknown;
-    readonly commits: readonly (string | {
-        readonly sha: string;
-    })[];
-    readonly branch: string;
-    readonly headSha: string;
-    readonly report: PhaseReport;
-    readonly artifacts?: readonly PhaseArtifact[];
-    readonly preservedWorktreePath?: string;
-    readonly outcome?: "completed" | "needs-info";
-}
-interface PhaseEngineAdapter {
-    /**
-     * Execute one phase. After `request.signal` aborts, this promise MUST settle
-     * only after the provider has stopped all work that can mutate the candidate.
-     */
-    execute(request: PhaseEngineRequest): Promise<PhaseEngineResponse>;
-}
-interface FakePhaseEngineAdapterOptions {
-    readonly response?: PhaseEngineResponse;
-    readonly respond?: (request: PhaseEngineRequest) => Promise<PhaseEngineResponse>;
-}
-declare const createFakePhaseEngineAdapter: (options: FakePhaseEngineAdapterOptions) => PhaseEngineAdapter;
-type PhaseExecutionStatus = "completed" | "needs-info" | "provider-failure" | "cancelled" | "timed-out" | "failed-verification";
-interface PhaseFailure {
-    readonly kind: "provider" | "timeout" | "cancellation" | "validation";
-    readonly message: string;
-}
-interface PhaseExecutionResult {
-    readonly status: PhaseExecutionStatus;
-    readonly phaseResult: PhaseResult;
-    readonly output?: unknown;
-    readonly failure?: PhaseFailure;
-}
-interface ExecutePhaseOptions {
-    readonly assignment: Assignment;
-    /** Dedicated mutation branch for implementation and repair phases. */
-    readonly branch?: string;
-    readonly trusted: TrustedPhaseInputs;
-    readonly untrusted: UntrustedPhaseInputs;
-    readonly controls: PhaseControls;
-    readonly adapter: PhaseEngineAdapter;
-    readonly artifactStore: ArtifactStore;
-    readonly credentialResolver: CredentialResolver;
-    readonly output?: OutputDefinition;
-    readonly signal?: AbortSignal;
-}
-declare const executePhase: (options: ExecutePhaseOptions) => Promise<PhaseExecutionResult>;
-type PhaseAgentResolver = {
-    /** Pre-resolved provider for legacy single-model policies. */
-    readonly agent: AgentProvider;
-    readonly resolveAgent?: never;
-} | {
-    readonly agent?: never;
-    /** Creates the provider selected by the assignment's trusted policy. */
-    readonly resolveAgent: (selection: AgentSelection) => AgentProvider;
-};
-type RunPhaseEngineAdapterOptions = PhaseAgentResolver & {
-    readonly sandbox: SandboxProvider;
-    readonly cwd?: string;
-    readonly run: (options: RunOptions) => Promise<RunResult & {
-        output?: unknown;
-    }>;
-};
-declare const createRunPhaseEngineAdapter: (options: RunPhaseEngineAdapterOptions) => PhaseEngineAdapter;
-type CreateSandboxPhaseEngineAdapterOptions = PhaseAgentResolver & {
-    readonly sandbox: SandboxProvider;
-    readonly cwd?: string;
-    readonly createSandbox: (options: CreateSandboxOptions) => Promise<Sandbox>;
-};
-declare const createCreateSandboxPhaseEngineAdapter: (options: CreateSandboxPhaseEngineAdapterOptions) => PhaseEngineAdapter;
-
-interface HandoffCandidate {
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly briefHash: string;
-}
-interface BranchProtectionState {
-    readonly enforced: boolean;
-    readonly humanApprovalRequired: boolean;
-    /** Fresh provider evidence; caller-supplied booleans alone are not a merge gate. */
-    readonly provider: "github";
-    readonly verifiedAt: string;
-}
-interface HumanApproval {
-    readonly actor: string;
-    readonly actorRole: "owner" | "maintainer";
-    readonly approvedAt: string;
-    readonly baseSha: string;
-    readonly headSha: string;
-    readonly briefHash: string;
-}
-interface HandoffReadinessInput {
-    readonly job: WorkflowJob;
-    readonly candidate: HandoffCandidate;
-    readonly checks: readonly CheckEvidence[];
-    readonly review: ReviewEvidence;
-    readonly requiredAxes?: readonly ReviewAxis[];
-    readonly branchProtection?: BranchProtectionState;
-    readonly humanApproval?: HumanApproval;
-    readonly now?: () => string;
-    readonly freshnessWindowSeconds?: number;
-}
-interface HandoffPacket {
-    readonly sourceIssue: string;
-    readonly pullRequest?: string;
-    readonly candidate: HandoffCandidate;
-    readonly briefRevision: number;
-    readonly briefHash: string;
-    readonly change: string;
-    readonly risk: WorkBrief["risk"];
-    readonly acceptanceCriteria: readonly string[];
-    readonly acceptanceEvidence: readonly string[];
-    readonly checks: readonly CheckEvidence[];
-    readonly reviewAxes: readonly ReviewAxis[];
-    readonly findings: readonly Finding[];
-    readonly limitations: readonly string[];
-}
-type HandoffOutcome = "blocked" | "ready-for-review" | "review-requested"
-/** Retained for source-item triage; PR handoff uses ready-for-review. */
- | "ready-for-human" | "repair-needed" | "rejected" | "abandoned" | "merge-ready" | "merged" | "open";
-interface HandoffReadinessResult {
-    readonly outcome: "blocked" | "ready-for-review" | "review-requested" | "merge-ready";
-    readonly readyForReview: boolean;
-    readonly reviewRequested: boolean;
-    readonly readyForHuman: boolean;
-    readonly mergeReady: boolean;
-    readonly reasons: readonly string[];
-    readonly packet: HandoffPacket;
-}
-interface HumanHandoffPublisher {
-    requestReview(input: {
-        readonly packet: HandoffPacket;
-        readonly pullRequestNumber: number;
-    }): Promise<void>;
-}
-interface PrepareHandoffOptions extends HandoffReadinessInput {
-    readonly sourceIssueNumber: number;
-    readonly pullRequestNumber: number;
-    readonly publisher?: HumanHandoffPublisher;
-    readonly readCurrent?: () => Promise<HandoffCandidate>;
-}
-interface HumanReviewDecisionInput {
-    readonly decision: "approved" | "changes-requested" | "rejected" | "abandoned";
-    readonly reason?: string;
-}
-interface HumanReviewDecision {
-    readonly outcome: Extract<HandoffOutcome, "merge-ready" | "repair-needed" | "rejected" | "abandoned">;
-    readonly reason?: string;
-}
-interface HumanReviewRoundTripOptions {
-    readonly candidate: HandoffCandidate;
-    readonly pullRequestNumber: number;
-    readonly decision: HumanReviewDecisionInput;
-    /** Re-reads the PR head and brief before applying the human decision. */
-    readonly readCurrent: () => Promise<HandoffCandidate>;
-    /** Keeps a requested-changes repair on the existing PR branch. */
-    readonly requestRepair: (input: {
-        readonly candidate: HandoffCandidate;
-        readonly pullRequestNumber: number;
-        readonly reason: string;
-    }) => Promise<void>;
-}
-interface HumanReviewRoundTripResult {
-    readonly outcome: "blocked" | Extract<HandoffOutcome, "merge-ready" | "repair-needed" | "rejected" | "abandoned">;
-    readonly reason?: string;
-    readonly candidate: HandoffCandidate;
-    readonly pullRequestNumber: number;
-}
-interface MergeTransport {
-    mergeProtected(input: {
-        readonly pullRequestNumber: number;
-        readonly headSha: string;
-        readonly baseBranch: string;
-    }): Promise<{
-        readonly mergedSha: string;
-    }>;
-}
-interface MergeCandidateOptions extends Omit<HandoffReadinessInput, "branchProtection"> {
-    readonly pullRequestNumber: number;
-    readonly humanApproval: HumanApproval;
-    /** Re-reads the PR, branch and brief identity immediately before merging. */
-    readonly readCurrent: () => Promise<HandoffCandidate>;
-    /** Fetches fresh provider evidence immediately before a protected merge. */
-    readonly readBranchProtection: () => Promise<BranchProtectionState>;
-    readonly transport: MergeTransport;
-}
-interface MergeResult {
-    readonly outcome: "blocked" | "merged";
-    readonly reason?: string;
-    readonly mergedSha?: string;
-}
-interface CompletionInput {
-    readonly policy: RepositoryPolicy;
-    readonly mergedSha: string;
-    readonly candidate: HandoffCandidate;
-    readonly checks: readonly CheckEvidence[];
-}
-interface CompletionResult {
-    readonly outcome: "completed" | "open";
-    readonly reason?: string;
-    readonly mergedSha: string;
-    readonly checks: readonly CheckEvidence[];
-}
-interface SourceIssueCloser {
-    closeIssue(input: {
-        readonly issueNumber: number;
-        readonly mergedSha: string;
-        readonly checks: readonly CheckEvidence[];
-    }): Promise<void>;
-}
-interface CloseSourceIssueOptions extends CompletionInput {
-    readonly sourceIssueNumber: number;
-    readonly closer: SourceIssueCloser;
-}
-interface SourceIssueClosureResult extends CompletionResult {
-    readonly closed: boolean;
-}
-declare const evaluateHandoffReadiness: (input: HandoffReadinessInput) => HandoffReadinessResult;
-declare const prepareHumanHandoff: (input: PrepareHandoffOptions) => Promise<HandoffReadinessResult>;
-declare const resolveHumanReviewDecision: (input: HumanReviewDecisionInput) => HumanReviewDecision;
-declare const processHumanReviewDecision: (input: HumanReviewRoundTripOptions) => Promise<HumanReviewRoundTripResult>;
-declare const mergeProtectedCandidate: (input: MergeCandidateOptions) => Promise<MergeResult>;
-declare const completeSourceIssue: (input: CompletionInput) => CompletionResult;
-declare const closeSourceIssue: (input: CloseSourceIssueOptions) => Promise<SourceIssueClosureResult>;
-
-interface GitHubWebhookSignatureInput {
-    readonly body: string | Uint8Array;
-    readonly signature?: string;
-    readonly secret: string | Uint8Array;
-}
-/**
- * Verifies GitHub's `X-Hub-Signature-256` value without exposing the secret.
- * Malformed values are compared against a same-sized zero buffer so the final
- * digest comparison always uses the constant-time primitive.
- */
-declare const verifyGitHubWebhookSignature: (input: GitHubWebhookSignatureInput) => boolean;
-
-type TriageCategory = "bug" | "enhancement" | "support" | "duplicate" | "sensitive" | "non-actionable";
-type TriageOutcome = "completed" | "needs-info" | "duplicate" | "sensitive" | "non-actionable" | "blocked" | "failed";
-interface TriageSource {
-    readonly provider: "github" | "slack" | "manual";
-    readonly repository: string;
-    readonly itemId: string;
-    readonly title: string;
-    readonly body: string;
-    readonly author?: string;
-    readonly url?: string;
-    readonly updatedAt: string;
-    readonly kind?: WorkItemKind;
-    readonly labels?: readonly string[];
-}
-interface ClarificationReply {
-    readonly id: string;
-    readonly body: string;
-    readonly author?: string;
-    readonly updatedAt: string;
-}
-interface TriageAssessment {
-    readonly category: TriageCategory;
-    readonly evidence: readonly string[];
-    readonly relevantFiles: readonly string[];
-    readonly acceptanceCriteria: readonly string[];
-    readonly exclusions: readonly string[];
-    readonly risk: RiskLevel;
-    readonly verification: readonly string[];
-    readonly unresolvedQuestions: readonly string[];
-    readonly requirementsConfirmed: boolean;
-    readonly duplicateOf?: string;
-    readonly sensitiveReason?: string;
-}
-interface TriageInvestigationRequest {
-    readonly source: TriageSource;
-    readonly policy: RepositoryPolicy;
-    readonly base: RevisionReference;
-    readonly previous?: TriageRecord;
-    readonly clarificationReply?: ClarificationReply;
-}
-type TriageInvestigator = ((request: TriageInvestigationRequest) => Promise<TriageAssessment>) | {
-    investigate(request: TriageInvestigationRequest): Promise<TriageAssessment>;
-};
-interface TriageRecord {
-    readonly id: string;
-    readonly sourceKey: string;
-    /** Retained for durable investigation and resumption; never used as public output. */
-    readonly source: TriageSource;
-    readonly sourceUpdatedAt: string;
-    readonly sourceFingerprint: string;
-    readonly revision: number;
-    readonly category: TriageCategory;
-    readonly outcome: TriageOutcome;
-    readonly assessment: TriageAssessment;
-    readonly brief?: WorkBrief;
-    readonly questions: readonly string[];
-    readonly clarificationIds: readonly string[];
-    readonly duplicateOf?: string;
-    readonly publicMessage: string;
-    readonly createdAt: string;
-    readonly updatedAt: string;
-}
-interface TriageStore {
-    get(sourceKey: string): TriageRecord | undefined;
-    save(record: TriageRecord): void;
-}
-declare class InMemoryTriageStore implements TriageStore {
-    private readonly records;
-    get(sourceKey: string): TriageRecord | undefined;
-    save(record: TriageRecord): void;
-}
-interface RunTriageOptions {
-    readonly source: TriageSource;
-    readonly policy: RepositoryPolicy;
-    readonly base: RevisionReference;
-    readonly store: TriageStore;
-    readonly investigator?: TriageInvestigator;
-    readonly clarificationReply?: ClarificationReply;
-    readonly now?: () => string;
-}
-interface TriageResult {
-    readonly outcome: TriageOutcome;
-    readonly category: TriageCategory;
-    readonly brief?: WorkBrief;
-    readonly questions: readonly string[];
-    readonly publicMessage: string;
-    readonly record: TriageRecord;
-    readonly implementationEligible: boolean;
-}
-declare const defaultInvestigator: TriageInvestigator;
-declare const runTriage: ({ source: rawSource, policy, base, store, investigator, clarificationReply, now, }: RunTriageOptions) => Promise<TriageResult>;
-
-type GitHubEventName = "issues" | "issue_comment" | "pull_request" | "pull_request_review" | "pull_request_review_comment" | "check_run" | "check_suite";
-type GitHubActorType = "User" | "Bot" | "Organization" | string;
-interface GitHubActor {
-    readonly login: string;
-    readonly type?: GitHubActorType;
-}
-interface GitHubIssueSnapshot {
-    readonly number: number;
-    readonly title: string;
-    readonly body: string;
-    readonly state: "open" | "closed";
-    readonly updatedAt: string;
-    readonly htmlUrl?: string;
-    readonly authorLogin?: string;
-    readonly labels: readonly string[];
-    readonly pullRequestNumber?: number;
-}
-interface GitHubCommentSnapshot {
-    readonly id: string;
-    readonly body: string;
-    readonly updatedAt: string;
-    readonly htmlUrl?: string;
-    readonly authorLogin?: string;
-}
-interface GitHubPullRequestSnapshot {
-    readonly number: number;
-    readonly title: string;
-    readonly body: string;
-    readonly state: "open" | "closed";
-    readonly draft: boolean;
-    readonly branch: string;
-    readonly baseBranch: string;
-    readonly headSha: string;
-    readonly updatedAt: string;
-    readonly htmlUrl?: string;
-    readonly authorLogin?: string;
-}
-type GitHubPullRequestReviewState = "approved" | "changes-requested" | "commented" | "dismissed" | "pending";
-interface GitHubPullRequestReviewSnapshot {
-    readonly id: string;
-    readonly state: GitHubPullRequestReviewState;
-    readonly headSha: string;
-    readonly submittedAt: string;
-    readonly authorLogin?: string;
-}
-interface GitHubBranchSnapshot {
-    readonly name: string;
-    readonly headSha: string;
-    readonly htmlUrl?: string;
-}
-interface GitHubCheckSnapshot {
-    readonly id: string;
-    readonly name: string;
-    readonly headSha: string;
-    readonly status: "queued" | "in_progress" | "completed";
-    readonly conclusion?: "success" | "failure" | "neutral" | "cancelled" | "timed_out" | "action_required" | "stale" | "skipped";
-    readonly htmlUrl?: string;
-}
-interface GitHubWebhookRequest {
-    readonly body: string | Uint8Array;
-    readonly headers: Readonly<Record<string, string | undefined>>;
-}
-interface GitHubWebhookEnvelope {
-    readonly eventName: string;
-    readonly deliveryId: string;
-    readonly payload: unknown;
-    readonly receivedAt: string;
-}
-interface GitHubAuthorizationPolicy {
-    /** Exact repository names allowed to produce workflow input. */
-    readonly allowedRepositories: readonly string[];
-    /** Exact GitHub logins allowed to submit workflow input. */
-    readonly allowedSenders: readonly string[];
-    /** Exact GitHub logins allowed to approve or request changes on tracked pull requests. */
-    readonly allowedReviewers: readonly string[];
-    /** Additional service logins treated as bot-originated. */
-    readonly botLogins?: readonly string[];
-}
-interface GitHubBriefDefaults {
-    readonly risk?: RiskLevel;
-    readonly acceptanceCriteria?: readonly string[];
-    readonly exclusions?: readonly string[];
-    readonly unresolvedQuestions?: readonly string[];
-    readonly verificationArtifacts?: readonly string[];
-}
-type GitHubIssueEventKind = "issue-created" | "issue-edited" | "issue-replied";
-type GitHubTrackedPullRequestEventKind = "tracked-pr-updated";
-type GitHubNormalizedEventKind = GitHubIssueEventKind | GitHubTrackedPullRequestEventKind;
-type GitHubEventIgnoreReason = "unsupported-event" | "unsupported-action" | "bot-originated" | "unrelated-pull-request";
-interface GitHubNormalizedEvent {
-    readonly kind: GitHubNormalizedEventKind;
-    readonly eventName: GitHubEventName;
-    readonly action: string;
-    readonly deliveryId: string;
-    readonly repository: string;
-    readonly sender: GitHubActor;
-    readonly issueNumber: number;
-    readonly pullRequestNumber?: number;
-    readonly title: string;
-    readonly body: string;
-    readonly labels: readonly string[];
-    readonly relevantRevision: string;
-    readonly observedAt: string;
-    readonly sourceState: "open" | "closed";
-    readonly reply?: GitHubCommentSnapshot;
-    readonly review?: GitHubPullRequestReviewSnapshot;
-    readonly trackedPullRequest?: GitHubTrackedPullRequest;
-    readonly workflowEvent: WorkflowEventInput;
-}
-interface GitHubIgnoredEvent {
-    readonly disposition: "ignored";
-    readonly reason: GitHubEventIgnoreReason;
-    readonly eventName: string;
-    readonly action?: string;
-    readonly deliveryId: string;
-    readonly repository: string;
-    readonly sender: GitHubActor;
-}
-type GitHubNormalizationResult = {
-    readonly disposition: "accepted";
-    readonly event: GitHubNormalizedEvent;
-} | GitHubIgnoredEvent;
-type GitHubDeliveryStatus = "received" | "accepted" | "ignored" | "rejected";
-interface GitHubDeliveryRecord {
-    readonly deliveryId: string;
-    readonly eventName: string;
-    readonly repository: string;
-    readonly senderLogin: string;
-    readonly receivedAt: string;
-    readonly payloadHash: string;
-    readonly payload: unknown;
-    readonly status: GitHubDeliveryStatus;
-    readonly eventKind?: GitHubNormalizedEventKind;
-    readonly reason?: string;
-    readonly jobId?: string;
-}
-interface GitHubDeliveryStore {
-    recordDeliveryIfAbsent(delivery: GitHubDeliveryRecord): Promise<{
-        readonly delivery: GitHubDeliveryRecord;
-        readonly inserted: boolean;
-    }>;
-    getDelivery(deliveryId: string): Promise<GitHubDeliveryRecord | undefined>;
-    updateDelivery(delivery: GitHubDeliveryRecord): Promise<void>;
-}
-interface GitHubTrackedPullRequest {
-    readonly repository: string;
-    readonly pullRequestNumber: number;
-    readonly jobId: string;
-    readonly itemId: string;
-    readonly branch: string;
-    readonly headSha: string;
-    readonly marker: string;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly createdAt: string;
-}
-interface GitHubPullRequestReviewHandler {
-    readCurrent(input: {
-        readonly candidate: HandoffCandidate;
-        readonly trackedPullRequest: GitHubTrackedPullRequest;
-    }): Promise<HandoffCandidate>;
-    requestRepair(input: {
-        readonly candidate: HandoffCandidate;
-        readonly pullRequestNumber: number;
-        readonly reason: string;
-    }): Promise<void>;
-}
-interface GitHubTrackingStore {
-    findTrackedPullRequest(repository: string, pullRequestNumber: number): Promise<GitHubTrackedPullRequest | undefined>;
-    saveTrackedPullRequest(pullRequest: GitHubTrackedPullRequest): Promise<void>;
-}
-interface GitHubBriefFactoryInput {
-    readonly event: Omit<GitHubNormalizedEvent, "workflowEvent">;
-    readonly itemKind: "planning-spec" | "executable-issue" | "pr-repair";
-    readonly policy: RepositoryPolicy;
-    readonly base: RevisionReference;
-    readonly authorization: Authorization;
-    readonly revision: number;
-    readonly defaults?: GitHubBriefDefaults;
-}
-type GitHubBriefFactory = (input: GitHubBriefFactoryInput) => WorkBrief;
-interface GitHubIntegrationOptions {
-    readonly coordinator: WorkflowCoordinator;
-    readonly policy: RepositoryPolicy;
-    readonly base: RevisionReference;
-    readonly authorization: GitHubAuthorizationPolicy;
-    readonly deliveryStore: GitHubDeliveryStore;
-    readonly webhookSecret: string | Uint8Array;
-    readonly trackingStore?: GitHubTrackingStore;
-    /** Review events fail closed unless the caller wires candidate-bound handoff handling. */
-    readonly reviewHandler?: GitHubPullRequestReviewHandler;
-    readonly briefDefaults?: GitHubBriefDefaults;
-    readonly briefFactory?: GitHubBriefFactory;
-    /** Optional automatic investigation adapter; absent means intake remains raw triage. */
-    readonly triage?: {
-        readonly store: TriageStore;
-        readonly investigator?: TriageInvestigator;
-    };
-    readonly now?: () => string;
-}
-interface GitHubWebhookReceipt {
-    readonly status: "accepted" | "duplicate" | "ignored" | "rejected";
-    readonly deliveryId: string;
-    readonly reason?: string;
-    readonly event?: GitHubNormalizedEvent;
-    readonly ingest?: IngestResult;
-    readonly review?: HumanReviewRoundTripResult;
-}
-interface GitHubReconciliationInput {
-    readonly repository: string;
-    readonly issueNumber?: number;
-    readonly pullRequestNumber?: number;
-    readonly transport: GitHubReadTransport;
-}
-interface GitHubReconciliationResult {
-    readonly status: "accepted" | "duplicate" | "ignored" | "not-found";
-    readonly deliveryId: string;
-    readonly reason?: string;
-    readonly event?: GitHubNormalizedEvent;
-    readonly ingest?: IngestResult;
-}
-interface GitHubReadTransport {
-    fetchIssue(input: {
-        readonly repository: string;
-        readonly issueNumber: number;
-    }): Promise<GitHubIssueSnapshot | undefined>;
-    fetchPullRequest(input: {
-        readonly repository: string;
-        readonly pullRequestNumber: number;
-    }): Promise<GitHubPullRequestSnapshot | undefined>;
-    findCommentByMarker(input: {
-        readonly repository: string;
-        readonly issueNumber: number;
-        readonly marker: string;
-    }): Promise<GitHubCommentSnapshot | undefined>;
-    findBranchByName(input: {
-        readonly repository: string;
-        readonly branch: string;
-    }): Promise<GitHubBranchSnapshot | undefined>;
-    findPullRequestByMarker(input: {
-        readonly repository: string;
-        readonly marker: string;
-    }): Promise<GitHubPullRequestSnapshot | undefined>;
-    findCheckByMarker(input: {
-        readonly repository: string;
-        readonly marker: string;
-        readonly headSha: string;
-    }): Promise<GitHubCheckSnapshot | undefined>;
-    findIssueByMarker(input: {
-        readonly repository: string;
-        readonly marker: string;
-    }): Promise<GitHubIssueSnapshot | undefined>;
-}
-interface GitHubWriteTransport {
-    createComment(input: {
-        readonly repository: string;
-        readonly issueNumber: number;
-        readonly body: string;
-    }): Promise<GitHubCommentSnapshot>;
-    createBranch(input: {
-        readonly repository: string;
-        readonly branch: string;
-        readonly headSha: string;
-        readonly marker: string;
-    }): Promise<GitHubBranchSnapshot>;
-    createPullRequest(input: {
-        readonly repository: string;
-        readonly title: string;
-        readonly body: string;
-        readonly branch: string;
-        readonly baseBranch: string;
-        readonly draft: boolean;
-        readonly marker: string;
-    }): Promise<GitHubPullRequestSnapshot>;
-    createCheck(input: {
-        readonly repository: string;
-        readonly name: string;
-        readonly headSha: string;
-        readonly marker: string;
-        readonly status: GitHubCheckSnapshot["status"];
-        readonly conclusion?: GitHubCheckSnapshot["conclusion"];
-        readonly summary: string;
-    }): Promise<GitHubCheckSnapshot>;
-    createRepairIssue(input: {
-        readonly repository: string;
-        readonly title: string;
-        readonly body: string;
-        readonly marker: string;
-        readonly labels: readonly string[];
-    }): Promise<GitHubIssueSnapshot>;
-}
-interface GitHubPublicationOptions {
-    readonly coordinator: WorkflowCoordinator;
-    readonly transport: GitHubReadTransport & GitHubWriteTransport;
-    readonly trackingStore: GitHubTrackingStore;
-    readonly now?: () => string;
-}
-interface GitHubPublicationResult<T> {
-    readonly marker: string;
-    readonly remote: T | undefined;
-    readonly disposition: EffectExecution<T>["disposition"];
-    readonly effect: EffectIntent;
-}
-interface GitHubCommentPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly issueNumber: number;
-    readonly body: string;
-    readonly key?: string;
-}
-interface GitHubBriefPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly issueNumber: number;
-    readonly brief: WorkBrief;
-}
-interface GitHubBranchPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly branch: string;
-    readonly headSha: string;
-}
-interface GitHubPullRequestPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly title: string;
-    readonly body: string;
-    readonly branch: string;
-    readonly baseBranch: string;
-    readonly headSha: string;
-    readonly draft?: boolean;
-}
-interface GitHubCheckPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    /** Candidate branch used to bind the check to the active lease. */
-    readonly branch?: string;
-    readonly name: string;
-    readonly headSha: string;
-    readonly status: GitHubCheckSnapshot["status"];
-    readonly conclusion?: GitHubCheckSnapshot["conclusion"];
-    readonly summary: string;
-    readonly key?: string;
-}
-interface GitHubRepairIssuePublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly title: string;
-    readonly body: string;
-    readonly labels?: readonly string[];
-}
-interface GitHubRepairLinkPublicationInput {
-    readonly jobId: string;
-    readonly lease: BranchLease;
-    readonly issueNumber: number;
-    readonly repairIssueUrl: string;
-}
-
-/**
- * Small in-memory adapter for tests and local development. Production callers
- * should provide a durable adapter with the same atomic insert semantics.
- */
-declare class InMemoryGitHubStore implements GitHubDeliveryStore, GitHubTrackingStore {
-    private readonly deliveries;
-    private readonly trackedPullRequests;
-    recordDeliveryIfAbsent(delivery: GitHubDeliveryRecord): Promise<{
-        readonly delivery: GitHubDeliveryRecord;
-        readonly inserted: boolean;
-    }>;
-    getDelivery(deliveryId: string): Promise<GitHubDeliveryRecord | undefined>;
-    updateDelivery(delivery: GitHubDeliveryRecord): Promise<void>;
-    findTrackedPullRequest(repository: string, pullRequestNumber: number): Promise<GitHubTrackedPullRequest | undefined>;
-    saveTrackedPullRequest(pullRequest: GitHubTrackedPullRequest): Promise<void>;
-}
-
-declare const reviewDecisionFor: (review: GitHubPullRequestReviewSnapshot) => HumanReviewDecisionInput | undefined;
-declare const createGitHubIssueBrief: (input: GitHubBriefFactoryInput) => WorkBrief;
-declare class GitHubIntegration {
-    private readonly options;
-    private readonly now;
-    constructor(options: GitHubIntegrationOptions);
-    receiveWebhook(request: GitHubWebhookRequest): Promise<GitHubWebhookReceipt>;
-    normalize(envelope: GitHubWebhookEnvelope): Promise<GitHubNormalizationResult>;
-    reconcile(input: GitHubReconciliationInput): Promise<GitHubReconciliationResult>;
-    private processEnvelope;
-    private rejectStored;
-    private ignoreStored;
-    private briefForIssue;
-    private normalizeTrackedPullRequest;
-    private issuePayload;
-    private pullRequestPayload;
-    private toReconciliationResult;
-}
-
-/** Coordinator-owned GitHub effects with stable markers and remote reconciliation. */
-declare class GitHubPublication {
-    private readonly options;
-    constructor(options: GitHubPublicationOptions);
-    publishComment(input: GitHubCommentPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
-    publishBrief(input: GitHubBriefPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
-    publishBranch(input: GitHubBranchPublicationInput): Promise<GitHubPublicationResult<GitHubBranchSnapshot>>;
-    publishPullRequest(input: GitHubPullRequestPublicationInput): Promise<GitHubPublicationResult<GitHubPullRequestSnapshot>>;
-    publishCheck(input: GitHubCheckPublicationInput): Promise<GitHubPublicationResult<GitHubCheckSnapshot>>;
-    publishRepairIssue(input: GitHubRepairIssuePublicationInput): Promise<GitHubPublicationResult<GitHubIssueSnapshot>>;
-    publishRepairLink(input: GitHubRepairLinkPublicationInput): Promise<GitHubPublicationResult<GitHubCommentSnapshot>>;
-}
-
-type ReviewRunOutcome = "passed" | "actionable-findings" | "incomplete" | "blocked" | "failed";
-interface ReviewCandidate {
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly requiredAxes?: readonly ReviewAxis[];
-}
-interface ReviewCheckout {
-    readonly base: RevisionReference;
-    readonly candidate: RevisionReference;
-    readonly immutable: true;
-}
-interface ReviewRequest {
-    readonly candidate: ReviewCandidate;
-    readonly checkout: ReviewCheckout;
-    readonly signal: AbortSignal;
-}
-interface ReviewFindingInput {
-    readonly id: string;
-    readonly severity: FindingSeverity;
-    readonly axis: ReviewAxis;
-    readonly title: string;
-    readonly evidence: string;
-    readonly location?: string;
-    readonly requirement?: string;
-    readonly verification?: string;
-}
-interface ReviewResponse {
-    readonly outcome?: ReviewRunOutcome;
-    readonly axes: readonly ReviewAxis[];
-    readonly findings: readonly ReviewFindingInput[];
-    readonly evidence: readonly string[];
-    readonly headSha: string;
-    readonly baseSha?: string;
-    readonly briefHash: string;
-    /** Any returned commit or changed file means the reviewer violated read-only review. */
-    readonly commits?: readonly string[];
-    readonly changedFiles?: readonly string[];
-}
-interface ReviewProvider {
-    review(request: ReviewRequest): Promise<ReviewResponse>;
-}
-interface CurrentCandidate {
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly briefHash: string;
-}
-interface IndependentReviewOptions {
-    readonly candidate: ReviewCandidate;
-    readonly provider: ReviewProvider;
-    readonly readCurrent?: () => Promise<CurrentCandidate>;
-    readonly signal?: AbortSignal;
-}
-interface ReviewFailure {
-    readonly kind: "provider" | "malformed" | "stale-candidate" | "mutation";
-    readonly message: string;
-}
-interface IndependentReviewResult {
-    readonly outcome: ReviewRunOutcome;
-    readonly candidate: ReviewCandidate;
-    readonly reviewAxes: readonly ReviewAxis[];
-    readonly findings: readonly Finding[];
-    readonly evidence: readonly string[];
-    readonly reviewEvidence: ReviewEvidence;
-    readonly failure?: ReviewFailure;
-}
-/** Run a read-only, candidate-bound review and normalize its evidence. */
-declare const runIndependentReview: (options: IndependentReviewOptions) => Promise<IndependentReviewResult>;
-
-interface CurrentImplementationCandidate {
-    readonly base: RevisionReference;
-    readonly briefHash: string;
-}
-interface ImplementationExecutionTemplate extends Omit<ExecutePhaseOptions, "assignment" | "branch"> {
-    readonly branch?: string;
-}
-interface AuthorizedImplementationOptions {
-    readonly coordinator: WorkflowCoordinator;
-    readonly publication: GitHubPublication;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly workerId: string;
-    readonly issueNumber?: number;
-    readonly branch?: string;
-    readonly execution?: ImplementationExecutionTemplate;
-    readonly readCurrent?: () => Promise<CurrentImplementationCandidate>;
-    readonly now?: () => string;
-    readonly leaseTtlMs?: number;
-}
-type ImplementationOutcome = "dispatched" | "completed" | "needs-info" | "blocked" | "failed";
-interface ImplementationPublication {
-    readonly brief?: GitHubPublicationResult<unknown>;
-    readonly checks: readonly GitHubPublicationResult<unknown>[];
-    readonly branch?: GitHubPublicationResult<unknown>;
-    readonly pullRequest?: GitHubPublicationResult<GitHubPullRequestSnapshot>;
-}
-interface AuthorizedImplementationResult {
-    readonly outcome: ImplementationOutcome;
-    readonly reason?: string;
-    readonly job?: WorkflowJob;
-    readonly dispatch?: DispatchResult;
-    readonly assignment?: Assignment;
-    readonly lease?: BranchLease;
-    readonly phaseResult?: PhaseResult;
-    readonly execution?: PhaseExecutionResult;
-    readonly publication?: ImplementationPublication;
-    readonly pullRequest?: GitHubPullRequestSnapshot;
-    readonly nextPhase?: "review";
-    readonly nextDispatch?: DispatchIntent;
-    readonly readyForReview: boolean;
-}
-interface ReviewSchedulingInput {
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly checks: readonly CheckEvidence[];
-    readonly requiredAxes?: ReviewCandidate["requiredAxes"];
-}
-interface ReviewSchedulingResult {
-    readonly status: "ready" | "blocked";
-    readonly reasons: readonly string[];
-    readonly candidate?: ReviewCandidate;
-}
-/** Build a review candidate only after the current implementation checks pass. */
-declare const prepareIndependentReview: (input: ReviewSchedulingInput) => ReviewSchedulingResult;
-declare const runAuthorizedImplementation: (options: AuthorizedImplementationOptions) => Promise<AuthorizedImplementationResult>;
-
-interface CostMeasurement {
-    readonly currency?: string;
-    readonly amount?: number;
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly provider?: string;
-    readonly model?: string;
-}
-interface OperatorStatusOptions {
-    readonly cost?: CostMeasurement;
-    readonly now?: string;
-}
-interface OperatorCheckStatus {
-    readonly name: string;
-    readonly command: string;
-    readonly status: CheckEvidence["status"];
-    readonly summary: string;
-    readonly artifactRefs?: readonly string[];
-}
-interface OperatorStatus {
-    readonly jobId: string;
-    readonly repository: string;
-    readonly itemId: string;
-    readonly kind: string;
-    readonly state: WorkflowJob["state"];
-    readonly control: WorkflowJob["control"];
-    readonly phase: WorkflowPhase;
-    readonly waitingReason?: string;
-    readonly queueAgeSeconds: number;
-    readonly attempts: Readonly<Record<WorkflowPhase, number>>;
-    readonly activeAssignmentId?: string;
-    readonly latestObservedAt: string;
-    readonly checks: readonly OperatorCheckStatus[];
-    readonly artifacts: readonly string[];
-    readonly cost: {
-        readonly status: "unknown";
-    } | ({
-        readonly status: "measured";
-    } & CostMeasurement);
-    readonly interventions: readonly OperatorIntervention[];
-    readonly repositoryControl?: RepositoryControl;
-}
-interface OperatorIntervention {
-    readonly action: "pause" | "cancel" | "resume" | "stop-repository" | "resume-repository";
-    readonly reason?: string;
-    readonly at: string;
-}
-interface WorkflowOperatorOptions {
-    readonly coordinator: WorkflowCoordinator;
-    readonly now?: () => string;
-}
-declare const redact: (value: string) => string;
-declare class WorkflowOperator {
-    private readonly coordinator;
-    private readonly now;
-    private readonly interventions;
-    constructor(options: WorkflowOperatorOptions);
-    status(jobId: string, options?: OperatorStatusOptions): Promise<OperatorStatus>;
-    pause(jobId: string, reason?: string): Promise<WorkflowJob>;
-    cancel(jobId: string, reason?: string): Promise<WorkflowJob>;
-    resume(jobId: string): Promise<WorkflowJob>;
-    stopRepository(repository: string, reason?: string): Promise<RepositoryControl>;
-    resumeRepository(repository: string): Promise<RepositoryControl>;
-    private record;
-}
-
-interface RepairCandidate {
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly briefHash: string;
-}
-interface RepairBatch {
-    readonly id: string;
-    readonly jobId: string;
-    readonly sourceIssueNumber?: number;
-    readonly pullRequestNumber?: number;
-    readonly candidate: RepairCandidate;
-    readonly brief: WorkBrief;
-    readonly findings: readonly Finding[];
-    readonly followUp: boolean;
-    readonly createdAt: string;
-}
-interface RepairBatchStore {
-    get(key: string): RepairBatchResult | undefined;
-    save(key: string, result: RepairBatchResult): void;
-}
-declare class InMemoryRepairBatchStore implements RepairBatchStore {
-    private readonly results;
-    get(key: string): RepairBatchResult | undefined;
-    save(key: string, result: RepairBatchResult): void;
-}
-interface CurrentRepairCandidate {
-    readonly base: RevisionReference;
-    readonly head: RevisionReference;
-    readonly briefHash: string;
-    readonly pullRequest?: GitHubPullRequestSnapshot;
-}
-interface ScheduleRepairOptions {
-    readonly coordinator: WorkflowCoordinator;
-    readonly publication: GitHubPublication;
-    readonly store: RepairBatchStore;
-    readonly jobId: string;
-    readonly brief: WorkBrief;
-    readonly policy: RepositoryPolicy;
-    readonly candidate: RepairCandidate;
-    readonly workerId: string;
-    readonly sourceIssueNumber?: number;
-    readonly pullRequestNumber?: number;
-    readonly followUp?: boolean;
-    readonly pullRequestState?: "open" | "closed";
-    readonly readCurrent?: () => Promise<CurrentRepairCandidate>;
-    readonly now?: () => string;
-    readonly leaseTtlMs?: number;
-}
-type RepairScheduleOutcome = "scheduled" | "duplicate" | "blocked";
-interface RepairBatchResult {
-    readonly outcome: RepairScheduleOutcome;
-    readonly reason?: string;
-    readonly batch: RepairBatch;
-    readonly job?: WorkflowJob;
-    readonly dispatch?: DispatchIntent;
-    readonly lease?: BranchLease;
-    readonly repairIssue?: GitHubIssueSnapshot;
-    readonly issuePublication?: GitHubPublicationResult<GitHubIssueSnapshot>;
-    readonly linkPublication?: GitHubPublicationResult<unknown>;
-}
-interface ScheduleRepairInput extends ScheduleRepairOptions {
-    readonly findings: readonly Finding[];
-}
-interface RepairExecutionTemplate extends Omit<ExecutePhaseOptions, "assignment" | "branch"> {
-    readonly branch?: string;
-}
-interface RunBoundedRepairOptions extends ScheduleRepairInput {
-    readonly execution: RepairExecutionTemplate;
-}
-interface BoundedRepairExecutionResult {
-    readonly outcome: "completed" | "needs-info" | "failed" | "blocked";
-    readonly reason?: string;
-    readonly repair: RepairBatchResult;
-    readonly assignment?: Assignment;
-    readonly dispatch?: DispatchResult;
-    readonly execution?: PhaseExecutionResult;
-    readonly phaseResult?: PhaseResult;
-    readonly nextPhase?: "checking" | "review";
-    readonly nextDispatch?: DispatchIntent;
-}
-declare const scheduleBoundedRepair: (input: ScheduleRepairInput) => Promise<RepairBatchResult>;
-/** Execute a scheduled repair on the existing leased branch; review remains a separate phase. */
-declare const runBoundedRepair: (input: RunBoundedRepairOptions) => Promise<BoundedRepairExecutionResult>;
-
-type ReleaseEnvironment = "staging" | "production";
-type ReleaseCheckStatus = "passed" | "failed" | "missing" | "unknown";
-interface ReleaseCandidate {
-    readonly sourceSha: string;
-    readonly reviewedHeadSha: string;
-    readonly briefHash: string;
-    readonly artifactDigest: string;
-    /** Provider-specific immutable locator; integrity is bound separately by artifactDigest. */
-    readonly artifactRef: string;
-    readonly version?: string;
-}
-interface ReleasePolicy {
-    readonly repository: string;
-    readonly stagingName: string;
-    readonly productionName: string;
-    readonly requiredStagingChecks: readonly string[];
-    readonly requireHumanApproval: boolean;
-    /** Maximum age for a production approval before it must be renewed. */
-    readonly approvalFreshnessSeconds?: number;
-    /** Roles allowed to approve production; release coordinators may request but not approve. */
-    readonly approvalRoles?: readonly ("owner" | "maintainer")[];
-    /** Recovery is recorded as a requested action; it is never inferred or executed by default. */
-    readonly recoveryMode: "roll-forward" | "rollback" | "owner-decision";
-}
-interface ReleaseActor {
-    readonly id: string;
-    readonly role: "release-coordinator" | "owner" | "maintainer";
-}
-interface ReleaseCheck {
-    readonly name: string;
-    readonly status: ReleaseCheckStatus;
-    readonly summary: string;
-}
-interface ReleaseVerification {
-    readonly environment: ReleaseEnvironment;
-    readonly candidate: ReleaseCandidate;
-    readonly deploymentId: string;
-    readonly checks: readonly ReleaseCheck[];
-    readonly smoke: "passed" | "failed" | "missing" | "unknown";
-    readonly health: "passed" | "failed" | "missing" | "unknown";
-    readonly recordedAt: string;
-    readonly failureReason?: string;
-}
-interface ProductionApproval {
-    readonly actor: ReleaseActor;
-    readonly approvedAt: string;
-    readonly candidate: ReleaseCandidate;
-}
-type ReleaseStateStatus = "staging-requested" | "staging-failed" | "staging-verified" | "production-approved" | "production-requested" | "production-failed" | "production-verified";
-interface ReleaseState {
-    readonly key: string;
-    readonly candidate: ReleaseCandidate;
-    readonly status: ReleaseStateStatus;
-    readonly staging?: ReleaseVerification;
-    readonly approval?: ProductionApproval;
-    readonly recovery?: RecoveryRecord;
-    readonly production?: ReleaseVerification;
-    readonly updatedAt: string;
-}
-interface ReleaseStore {
-    get(key: string): ReleaseState | undefined;
-    save(state: ReleaseState): void;
-}
-declare class InMemoryReleaseStore implements ReleaseStore {
-    private readonly states;
-    get(key: string): ReleaseState | undefined;
-    save(state: ReleaseState): void;
-}
-interface ReleaseTransport {
-    requestDeployment(input: {
-        readonly environment: ReleaseEnvironment;
-        readonly environmentName: string;
-        readonly candidate: ReleaseCandidate;
-        readonly actor: ReleaseActor;
-        readonly idempotencyKey: string;
-    }): Promise<{
-        readonly deploymentId: string;
-    }>;
-    reconcileDeployment?(input: {
-        readonly environment: ReleaseEnvironment;
-        readonly environmentName: string;
-        readonly candidate: ReleaseCandidate;
-        readonly idempotencyKey: string;
-    }): Promise<{
-        readonly deploymentId: string;
-    } | undefined>;
-}
-interface ReleaseIntegrationOptions {
-    readonly policy: ReleasePolicy;
-    readonly store: ReleaseStore;
-    readonly transport: ReleaseTransport;
-    readonly actor: ReleaseActor;
-    /** Validate a provider-specific immutable locator not covered by built-in formats. */
-    readonly validateArtifactRef?: (candidate: ReleaseCandidate) => string | undefined;
-    readonly now?: () => string;
-}
-interface ReleaseOperationResult {
-    readonly outcome: "requested" | "duplicate" | "verified" | "approved" | "blocked" | "failed";
-    readonly reason?: string;
-    readonly state?: ReleaseState;
-}
-interface RecoveryRecord {
-    readonly candidate: ReleaseCandidate;
-    readonly action: ReleasePolicy["recoveryMode"];
-    readonly reason: string;
-    readonly authorizedBy: ReleaseActor;
-    readonly recordedAt: string;
-}
-declare const releaseCandidateKey: (candidate: ReleaseCandidate) => string;
-declare class ReleaseIntegration {
-    private readonly policy;
-    private readonly store;
-    private readonly transport;
-    private readonly actor;
-    private readonly validateArtifactRef?;
-    private readonly now;
-    constructor(options: ReleaseIntegrationOptions);
-    private stateKey;
-    requestStaging(candidate: ReleaseCandidate): Promise<ReleaseOperationResult>;
-    recordStagingVerification(verification: ReleaseVerification): ReleaseOperationResult;
-    approveProduction(input: {
-        readonly candidate: ReleaseCandidate;
-        readonly approval: ProductionApproval;
-    }): ReleaseOperationResult;
-    promoteProduction(candidate: ReleaseCandidate): Promise<ReleaseOperationResult>;
-    private requestDeployment;
-    recordProductionVerification(verification: ReleaseVerification): ReleaseOperationResult;
-    recordRecovery(input: {
-        readonly candidate: ReleaseCandidate;
-        readonly reason: string;
-        readonly authorizedBy: ReleaseActor;
-    }): RecoveryRecord;
-}
-declare const candidateMatchesApproval: (candidate: ReleaseCandidate, approval: ProductionApproval) => boolean;
-
-export { type AcquireBranchLeaseInput, type AgentCommandOptions, type AgentModelRoles, type AgentProvider, type AgentRole, type AgentSelection, type AgentStreamEvent, type ArtifactStore, type Assignment, type Authorization, type AuthorizedImplementationOptions, type AuthorizedImplementationResult, type BoundedRepairExecutionResult, type BranchLease, type BranchProtectionState, BranchStrategy, CODEX_MODELS, CODEX_REASONING_EFFORTS, type CheckCommand, type CheckEvidence, type CheckStatus, type ClarificationReply, type ClaudeCodeOptions, type CloseResult, type CloseSourceIssueOptions, type CodexModelConfig, type CodexOptions, type CodexReasoningEffort, type CompletionInput, type CompletionResult, ContractValidationError, type CoordinatorClock, type CoordinatorStorage, type CoordinatorStorageTransaction, type CostMeasurement, type CreateAssignmentInput, type CreateRepositoryPolicyInput, type CreateSandboxOptions, type CreateSandboxPhaseEngineAdapterOptions, type CreateWorkBriefInput, type CreateWorktreeOptions, CredentialNotAllowedError, type CredentialResolver, CredentialUnavailableError, type CurrentCandidate, type CurrentImplementationCandidate, type CurrentRepairCandidate, CwdError, type DispatchBlockReason, type DispatchIntent, type DispatchRequest, type DispatchResult, type DispatchStatus, type EffectExecution, type EffectIntent, type EffectOperationContext, type EffectStatus, type EventIgnoreReason, type EventStatus, ExecResult, type ExecutePhaseOptions, type FakePhaseEngineAdapterOptions, type Finding, type FindingDisposition, type FindingSeverity, type GitHubActor, type GitHubActorType, type GitHubAuthorizationPolicy, type GitHubBranchPublicationInput, type GitHubBranchSnapshot, type GitHubBriefDefaults, type GitHubBriefFactory, type GitHubBriefFactoryInput, type GitHubBriefPublicationInput, type GitHubCheckPublicationInput, type GitHubCheckSnapshot, type GitHubCommentPublicationInput, type GitHubCommentSnapshot, type GitHubDeliveryRecord, type GitHubDeliveryStatus, type GitHubDeliveryStore, type GitHubEventIgnoreReason, type GitHubEventName, type GitHubIgnoredEvent, GitHubIntegration, type GitHubIntegrationOptions, type GitHubIssueEventKind, type GitHubIssueSnapshot, type GitHubNormalizationResult, type GitHubNormalizedEvent, type GitHubNormalizedEventKind, GitHubPublication, type GitHubPublicationOptions, type GitHubPublicationResult, type GitHubPullRequestPublicationInput, type GitHubPullRequestReviewHandler, type GitHubPullRequestReviewSnapshot, type GitHubPullRequestReviewState, type GitHubPullRequestSnapshot, type GitHubReadTransport, type GitHubReconciliationInput, type GitHubReconciliationResult, type GitHubRepairIssuePublicationInput, type GitHubRepairLinkPublicationInput, type GitHubTrackedPullRequest, type GitHubTrackedPullRequestEventKind, type GitHubTrackingStore, type GitHubWebhookEnvelope, type GitHubWebhookReceipt, type GitHubWebhookRequest, type GitHubWebhookSignatureInput, type GitHubWriteTransport, type HandoffCandidate, type HandoffOutcome, type HandoffPacket, type HandoffReadinessInput, type HandoffReadinessResult, type HostSessionLookup, type HumanApproval, type HumanHandoffPublisher, type HumanReviewDecision, type HumanReviewDecisionInput, type HumanReviewRoundTripOptions, type HumanReviewRoundTripResult, type ImplementationExecutionTemplate, type ImplementationOutcome, type ImplementationPublication, type InMemoryArtifactStore, InMemoryCoordinatorStorage, InMemoryGitHubStore, InMemoryReleaseStore, InMemoryRepairBatchStore, InMemoryTriageStore, type IndependentReviewOptions, type IndependentReviewResult, type InfrastructureFailureInput, type InfrastructureRetryResult, type IngestResult, type InteractiveOptions, type InteractiveResult, type IterationResult, type IterationUsage, type JobControl, LeaseBusyError, LeaseLostError, type LifecycleState, type LoggingOption, type MergeCandidateOptions, type MergeResult, MergeToHeadBranchStrategy, type MergeTransport, NamedBranchStrategy, type OperatorCheckStatus, type OperatorIntervention, type OperatorStatus, type OperatorStatusOptions, Output, type OutputDefinition, type OutputObjectDefinition, type OutputStringDefinition, type PhaseAgentResolver, type PhaseArtifact, type PhaseBudget, type PhaseCheckout, type PhaseControls, type PhaseCredentials, type PhaseEngineAdapter, type PhaseEngineRequest, type PhaseEngineResponse, type PhaseExecutionResult, type PhaseExecutionStatus, type PhaseFailure, type PhaseOutcome, type PhaseReport, type PhaseResult, type PhaseResultSubmission, type PostgresConnection, PostgresCoordinatorStorage, type PostgresCoordinatorStorageOptions, type PostgresQueryClient, type PostgresQueryResult, type PrepareHandoffOptions, type PrintCommand, type ProductionApproval, type PromptArgs, type PublishEffectInput, type RecoveryRecord, type ReleaseActor, type ReleaseCandidate, type ReleaseCheck, type ReleaseCheckStatus, type ReleaseEnvironment, ReleaseIntegration, type ReleaseIntegrationOptions, type ReleaseOperationResult, type ReleasePolicy, type ReleaseState, type ReleaseStateStatus, type ReleaseStore, type ReleaseTransport, type ReleaseVerification, type RepairBatch, type RepairBatchResult, type RepairBatchStore, type RepairBudgetUsage, type RepairCandidate, type RepairExecutionTemplate, type RepairRequestResult, type RepairScheduleOutcome, type RepositoryControl, type RepositoryPolicy, type ResumeSandboxRunResultOptions, type ReviewAxis, type ReviewCandidate, type ReviewCheckout, type ReviewEvidence, type ReviewFailure, type ReviewFindingInput, type ReviewProvider, type ReviewRequest, type ReviewResponse, type ReviewRunOutcome, type ReviewSchedulingInput, type ReviewSchedulingResult, type RevisionReference, type RiskLevel, type RunBoundedRepairOptions, type RunOptions, type RunPhaseEngineAdapterOptions, type RunResult, type RunTriageOptions, type Sandbox, type SandboxExecOptions, type SandboxHooks, type SandboxInteractiveOptions, type SandboxInteractiveResult, SandboxProvider, type SandboxRunOptions, type SandboxRunResult, type SchedulePhaseInput, type SchedulePhaseResult, type ScheduleRepairInput, type ScheduleRepairOptions, type SourceIssueCloser, type SourceIssueClosureResult, type SourceReference, type StoredEvent, StructuredOutputError, type SubmitPhaseResultInput, type Timeouts, type TransitionContext, type TriageAssessment, type TriageCategory, type TriageInvestigationRequest, type TriageInvestigator, type TriageOutcome, type TriageRecord, type TriageResult, type TriageSource, type TriageStore, type TrustedPhaseInputs, type UntrustedPhaseInputs, type VerificationPlan, WORKFLOW_CONTRACT_VERSION, type WorkBrief, type WorkIdentity, type WorkItemKind, type WorkKey, type WorkRisk, type WorkScope, type WorkerPolicy, WorkflowCoordinator, type WorkflowCoordinatorOptions, type WorkflowEventInput, type WorkflowJob, WorkflowOperator, type WorkflowOperatorOptions, type WorkflowPhase, type Worktree, type WorktreeBranchStrategy, type WorktreeCreateSandboxOptions, type WorktreeInteractiveOptions, type WorktreeRunOptions, type WorktreeRunResult, candidateMatchesApproval, claudeCode, claudeHostSessionPath, claudeSandboxSessionPath, closeSourceIssue, codex, completeSourceIssue, createAssignment, createCreateSandboxPhaseEngineAdapter, createFakePhaseEngineAdapter, createGitHubIssueBrief, createInMemoryArtifactStore, createRepositoryPolicy, createRunPhaseEngineAdapter, createSandbox, createWorkBrief, createWorktree, defaultInvestigator as defaultTriageInvestigator, encodeProjectPath, evaluateHandoffReadiness, executePhase, findClaudeSessionOnHost, findCodexSessionOnHost, interactive, isAuthorizationAllowed, mergeProtectedCandidate, parseCheckEvidence, parsePhaseResult, parseRepositoryPolicy, parseWorkBrief, prepareHumanHandoff, prepareIndependentReview, processHumanReviewDecision, redact as redactOperatorText, releaseCandidateKey, requireTransition, resolveAgentSelection, resolveHumanReviewDecision, reviewDecisionFor, run, runAuthorizedImplementation, runBoundedRepair, runIndependentReview, runTriage, scheduleBoundedRepair, transferClaudeSession, transferCodexSession, verifyGitHubWebhookSignature };
+export { AgentProvider, BranchStrategy, CloseResult, type CreateWorktreeOptions, CwdError, type HostSessionLookup, type InteractiveOptions, type InteractiveResult, IterationResult, LoggingOption, MergeToHeadBranchStrategy, NamedBranchStrategy, PromptArgs, Sandbox, SandboxHooks, SandboxProvider, Timeouts, type Worktree, type WorktreeBranchStrategy, type WorktreeCreateSandboxOptions, type WorktreeInteractiveOptions, type WorktreeRunOptions, type WorktreeRunResult, claudeHostSessionPath, claudeSandboxSessionPath, createWorktree, encodeProjectPath, findClaudeSessionOnHost, findCodexSessionOnHost, interactive, transferClaudeSession, transferCodexSession };