@smartergpt/lexrunner 1.0.0 → 1.2.1

package/dist/cli.d.ts

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { z } from 'zod';
+import { F as FrameOutcome, a as FrameEmitResult } from './types-CYMIAhy8.js';
+export { m as mcpToolError } from './adapters-DciX_uRh.js';
 import { Octokit } from '@octokit/rest';
+import '@smartergpt/lex/errors';
 
 /**
  * Gate execution result
@@ -18,6 +21,20 @@ declare const GateResult: z.ZodObject<{
     duration: z.ZodOptional<z.ZodNumber>;
     stdout: z.ZodOptional<z.ZodString>;
     stderr: z.ZodOptional<z.ZodString>;
+    failureKind: z.ZodOptional<z.ZodEnum<{
+        nonzero_exit: "nonzero_exit";
+        spawn_error: "spawn_error";
+        timeout: "timeout";
+    }>>;
+    timeoutCleanup: z.ZodOptional<z.ZodObject<{
+        method: z.ZodEnum<{
+            "process-group": "process-group";
+            taskkill: "taskkill";
+            "direct-child": "direct-child";
+        }>;
+        forceKilled: z.ZodBoolean;
+        descendantsReaped: z.ZodBoolean;
+    }, z.core.$strip>>;
     artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     attempts: z.ZodDefault<z.ZodNumber>;
     lastAttempt: z.ZodOptional<z.ZodString>;
@@ -48,6 +65,20 @@ declare const NodeResult: z.ZodObject<{
         duration: z.ZodOptional<z.ZodNumber>;
         stdout: z.ZodOptional<z.ZodString>;
         stderr: z.ZodOptional<z.ZodString>;
+        failureKind: z.ZodOptional<z.ZodEnum<{
+            nonzero_exit: "nonzero_exit";
+            spawn_error: "spawn_error";
+            timeout: "timeout";
+        }>>;
+        timeoutCleanup: z.ZodOptional<z.ZodObject<{
+            method: z.ZodEnum<{
+                "process-group": "process-group";
+                taskkill: "taskkill";
+                "direct-child": "direct-child";
+            }>;
+            forceKilled: z.ZodBoolean;
+            descendantsReaped: z.ZodBoolean;
+        }, z.core.$strip>>;
         artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
         attempts: z.ZodDefault<z.ZodNumber>;
         lastAttempt: z.ZodOptional<z.ZodString>;
@@ -852,6 +883,12 @@ declare class HealthChecker {
  */
 declare const healthChecker: HealthChecker;
 
+interface RegisteredCliCommand {
+    path: string;
+    kind: "group" | "operation";
+    description: string;
+}
+
 /**
  * Run-Centric Schemas for Tool-Grounded Interactions
  *
@@ -1139,6 +1176,18 @@ declare function buildStatusResponse(runState: StatusBuilderInput, options?: {
  * Artifacts include plan files, decision logs, failure logs, gate reports, and reports.
  */
 
+/**
+ * Artifact types with their path patterns
+ */
+declare const ARTIFACT_TYPES: {
+    readonly plan: "plan.json";
+    readonly decision: "decisions.ndjson";
+    readonly failure: "failures.ndjson";
+    readonly gate: "gates/**/report.json";
+    readonly report: "reports/*.md";
+    readonly log: "logs/*.log";
+};
+type ArtifactType = keyof typeof ARTIFACT_TYPES;
 /**
  * Input schema for listArtifacts
  */
@@ -1426,102 +1475,6 @@ interface RunStore {
     close(): Promise<void>;
 }
 
-/**
- * Execution Frame Types
- *
- * Types for capturing workflow execution as Frames for memory integration.
- * Implements AX-005: Frame emission for core workflows.
- *
- * AX Principle: Memory Is a Feature
- */
-
-/**
- * Frame outcome status
- */
-type FrameOutcome = "success" | "failure" | "partial";
-/**
- * Execution Frame schema
- *
- * Represents what was attempted, scope touched, outcome, and recommended next steps.
- */
-declare const ExecutionFrameSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        gate: "gate";
-        procedure: "procedure";
-        execution: "execution";
-        "merge-weave": "merge-weave";
-    }>;
-    reference_point: z.ZodString;
-    summary_caption: z.ZodString;
-    module_scope: z.ZodArray<z.ZodString>;
-    keywords: z.ZodArray<z.ZodString>;
-    outcome: z.ZodEnum<{
-        success: "success";
-        failure: "failure";
-        partial: "partial";
-    }>;
-    next_actions: z.ZodArray<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodObject<{
-        duration_ms: z.ZodOptional<z.ZodNumber>;
-        conflicts_resolved: z.ZodOptional<z.ZodNumber>;
-        gates_passed: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        gates_failed: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        artifacts: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        error: z.ZodOptional<z.ZodString>;
-        exit_code: z.ZodOptional<z.ZodNumber>;
-        run_id: z.ZodOptional<z.ZodString>;
-        plan_hash: z.ZodOptional<z.ZodString>;
-        turn_cost: z.ZodOptional<z.ZodObject<{
-            components: z.ZodObject<{
-                latencyMs: z.ZodNumber;
-                contextResetTokens: z.ZodNumber;
-                renegotiationCount: z.ZodNumber;
-                tokenBloat: z.ZodNumber;
-                attentionSwitchCount: z.ZodNumber;
-            }, z.core.$strip>;
-            weightedScore: z.ZodNumber;
-            eventCount: z.ZodNumber;
-            priorRunScore: z.ZodOptional<z.ZodNumber>;
-            improvement: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        tier_metrics: z.ZodOptional<z.ZodObject<{
-            totalTasks: z.ZodNumber;
-            byTier: z.ZodObject<{
-                senior: z.ZodNumber;
-                mid: z.ZodNumber;
-                junior: z.ZodNumber;
-            }, z.core.$strip>;
-            escalations: z.ZodNumber;
-            mismatches: z.ZodNumber;
-            tierMatchRate: z.ZodNumber;
-            escalationRate: z.ZodNumber;
-        }, z.core.$strip>>;
-        governed_by: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            constraintId: z.ZodString;
-            source: z.ZodEnum<{
-                persona: "persona";
-                baseline: "baseline";
-                learned: "learned";
-            }>;
-            action: z.ZodString;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type ExecutionFrame = z.infer<typeof ExecutionFrameSchema>;
-/**
- * Result of Frame emission
- */
-interface FrameEmitResult {
-    /** Whether the Frame was emitted successfully */
-    success: boolean;
-    /** The emitted Frame (if successful) */
-    frame?: ExecutionFrame;
-    /** Frame ID (if stored via Lex) */
-    frameId?: string;
-    /** Error message (if failed) */
-    error?: string;
-}
-
 /**
  * Run Lifecycle Manager
  *
@@ -1868,190 +1821,3422 @@ declare class RunManager {
 declare function createRunManager(baseDirOrOptions?: string | RunManagerOptions): RunManager;
 
 /**
- * Compute merge order levels using Kahn's algorithm with deterministic ordering
- * Returns array of levels, where each level contains item names that can be processed in parallel
- */
-declare function computeMergeOrder(plan: Plan): string[][];
-
-/**
- * GitHub API integration for PR discovery and metadata extraction
- * Maintains deterministic ordering and stable output
- * Includes error recovery with retry and circuit breaker patterns
+ * Controller coordination persistence contract.
+ *
+ * This contract is deliberately separate from the frozen RunStore contract.
+ * It coordinates which controller may advance a run and provides optimistic
+ * concurrency control for that run's serialized orchestration state.
  */
-
-interface GitHubPullRequest {
-    number: number;
-    title: string;
-    branch: string;
-    sha: string;
-    state: "open" | "closed" | "merged";
-    labels: string[];
-    author: string;
-    baseBranch: string;
-    createdAt: string;
-    updatedAt: string;
-    mergeable?: boolean;
-    body?: string | null;
-    draft?: boolean;
-    reviewRequested?: boolean;
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+interface ControllerLease {
+    runId: string;
+    controllerId: string;
+    leaseId: string;
+    /**
+     * Monotonically increasing token. A controller must present the exact token
+     * on every mutation so a superseded controller cannot write after takeover.
+     */
+    fencingToken: number;
+    acquiredAt: string;
+    renewedAt: string;
+    expiresAt: string;
 }
-interface GitHubConfig {
-    token?: string;
-    owner: string;
-    repo: string;
+interface ControllerLeaseCredential {
+    runId: string;
+    controllerId: string;
+    leaseId: string;
+    fencingToken: number;
 }
+
 /**
- * GitHub API client for PR operations with error recovery
+ * Agent work protocol contracts.
+ *
+ * These contracts describe the durable boundary between a run controller,
+ * workspace broker, worker, verifier, and human operator. They intentionally
+ * do not replace ADR-007's repair-specific TaskSnapshot/TaskReceipt contract.
+ *
+ * Portable intent lives in AgentTaskPacket_v1. Machine-local paths and runtime
+ * details live exclusively in ExecutionEnvelope_v1.
  */
-declare class GitHubAPI {
-    private octokit;
-    config: GitHubConfig;
-    private circuitBreaker;
-    private normalized;
-    constructor(config: GitHubConfig);
-    /**
-     * Get the underlying Octokit instance for advanced operations
-     * Use with caution - prefer using typed methods when available
-     */
-    getOctokit(): Octokit;
-    /**
-     * Normalize repository owner and name to match GitHub's canonical casing.
-     * This handles case-insensitive lookups where git remote URLs may have
-     * different casing than the actual GitHub repository.
-     */
-    private normalizeRepositoryName;
-    /**
-     * Extract HTTP status code from error object
-     */
-    private extractErrorStatus;
-    /**
-     * Discover open pull requests with stable ordering and error recovery
-     */
-    discoverPullRequests(state?: "open" | "closed" | "all"): Promise<GitHubPullRequest[]>;
-    /**
-     * Get repository information
-     */
-    getRepositoryInfo(): Promise<{
-        name: string;
-        fullName: string;
-        defaultBranch: string;
-        private: boolean;
-    }>;
-    /**
-     * Check if authentication is working
-     */
-    checkAuth(): Promise<{
-        authenticated: boolean;
-        user?: string;
+
+declare const AGENT_WORK_CONTRACT_VERSION: "1.0.0";
+/** Breaking receipt-only evolution; the surrounding agent-work v1 contracts remain unchanged. */
+declare const AGENT_TASK_RECEIPT_V2_VERSION: "2.0.0";
+/** Reproducible patch-byte profile used by AgentTaskReceipt_v2.patch_hash claims. */
+declare const AGENT_TASK_RECEIPT_PATCH_PROFILE: "git-diff-binary-v1";
+/** Breaking verification-only evolution for durable AgentTaskReceipt v2 evidence. */
+declare const AGENT_ENGINE_VERIFICATION_V2_VERSION: "2.0.0";
+/** A full Git object ID. Abbreviated SHAs are not safe concurrency preconditions. */
+declare const GitObjectId: z.ZodString;
+type GitObjectId = z.infer<typeof GitObjectId>;
+/** Independent authority lanes; false is an explicit denial. */
+declare const AuthorityEnvelope: z.ZodObject<{
+    edit: z.ZodBoolean;
+    git_write: z.ZodBoolean;
+    github_write: z.ZodBoolean;
+    external_runtime: z.ZodBoolean;
+    secrets: z.ZodBoolean;
+    signing: z.ZodBoolean;
+    release: z.ZodBoolean;
+}, z.core.$strict>;
+type AuthorityEnvelope = z.infer<typeof AuthorityEnvelope>;
+declare const WorkItem_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    work_item_id: z.ZodString;
+    revision: z.ZodNumber;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            manual: "manual";
+            github: "github";
+            jira: "jira";
+        }>;
+        external_id: z.ZodString;
+        revision: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        captured_at: z.ZodString;
+    }, z.core.$strict>;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        remote_url: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    title: z.ZodString;
+    objective: z.ZodString;
+    description: z.ZodString;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    constraints: z.ZodArray<z.ZodString>;
+    labels: z.ZodArray<z.ZodString>;
+    dependencies: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type WorkItem_v1 = z.infer<typeof WorkItem_v1>;
+declare const RunStatus: z.ZodEnum<{
+    created: "created";
+    blocked: "blocked";
+    completed: "completed";
+    planning: "planning";
+    ready: "ready";
+    verifying: "verifying";
+    failed: "failed";
+    paused: "paused";
+    cancelled: "cancelled";
+    executing: "executing";
+    delivering: "delivering";
+    awaiting_human: "awaiting_human";
+}>;
+type RunStatus = z.infer<typeof RunStatus>;
+/** Canonical orchestration state for one immutable WorkItem revision. */
+declare const Run_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    run_id: z.ZodString;
+    revision: z.ZodNumber;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    control_mode: z.ZodEnum<{
+        assisted: "assisted";
+        headless: "headless";
     }>;
-    /**
-     * Get a specific pull request by number
-     */
-    getPullRequest(prNumber: number): Promise<GitHubPullRequest | null>;
-    /**
-     * Update a pull request (e.g., to undraft it)
-     */
-    updatePullRequest(owner: string, repo: string, prNumber: number, updates: {
-        draft?: boolean;
-        title?: string;
-        body?: string;
-    }): Promise<void>;
-    /**
-     * Add a label to a pull request
-     */
-    addLabel(prNumber: number, label: string): Promise<void>;
-    /**
-     * Remove a label from a pull request
-     */
-    removeLabel(prNumber: number, label: string): Promise<void>;
-    /**
-     * Get labels for a pull request
-     */
-    getLabels(prNumber: number): Promise<string[]>;
-    /**
-     * Get repository info (for harvest)
-     */
-    getRepository(): Promise<{
-        default_branch: string;
-        [key: string]: any;
+    authority_ceiling: z.ZodObject<{
+        edit: z.ZodBoolean;
+        git_write: z.ZodBoolean;
+        github_write: z.ZodBoolean;
+        external_runtime: z.ZodBoolean;
+        secrets: z.ZodBoolean;
+        signing: z.ZodBoolean;
+        release: z.ZodBoolean;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        created: "created";
+        blocked: "blocked";
+        completed: "completed";
+        planning: "planning";
+        ready: "ready";
+        verifying: "verifying";
+        failed: "failed";
+        paused: "paused";
+        cancelled: "cancelled";
+        executing: "executing";
+        delivering: "delivering";
+        awaiting_human: "awaiting_human";
     }>;
-    /**
-     * Get a git reference (branch/tag SHA)
-     */
-    getRef(ref: string): Promise<{
-        object: {
-            sha: string;
-        };
+    active_controller_lease_id: z.ZodOptional<z.ZodString>;
+    attempt_ids: z.ZodArray<z.ZodString>;
+    current_attempt_id: z.ZodOptional<z.ZodString>;
+    resume_status: z.ZodOptional<z.ZodEnum<{
+        planning: "planning";
+        ready: "ready";
+        verifying: "verifying";
+        executing: "executing";
+        delivering: "delivering";
+    }>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    completed_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type Run_v1 = z.infer<typeof Run_v1>;
+declare const AttemptStatus: z.ZodEnum<{
+    blocked: "blocked";
+    verifying: "verifying";
+    verified: "verified";
+    failed: "failed";
+    cancelled: "cancelled";
+    prepared: "prepared";
+    leased: "leased";
+    launching: "launching";
+    running: "running";
+    receipt_submitted: "receipt_submitted";
+    accepted: "accepted";
+    rejected: "rejected";
+    inconclusive: "inconclusive";
+    launch_failed: "launch_failed";
+    quarantined: "quarantined";
+}>;
+type AttemptStatus = z.infer<typeof AttemptStatus>;
+declare function attemptStatusRequiresReceipt(status: AttemptStatus): boolean;
+declare function attemptStatusRequiresVerification(status: AttemptStatus): boolean;
+declare function isTerminalAttemptStatus(status: AttemptStatus): boolean;
+/** One worker try, bound to one immutable packet and pinned repository base. */
+declare const Attempt_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    attempt_id: z.ZodString;
+    revision: z.ZodNumber;
+    run_id: z.ZodString;
+    run_revision: z.ZodNumber;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    base_sha: z.ZodString;
+    workspace_lease_id: z.ZodOptional<z.ZodString>;
+    receipt_id: z.ZodOptional<z.ZodString>;
+    verification_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        verifying: "verifying";
+        verified: "verified";
+        failed: "failed";
+        cancelled: "cancelled";
+        prepared: "prepared";
+        leased: "leased";
+        launching: "launching";
+        running: "running";
+        receipt_submitted: "receipt_submitted";
+        accepted: "accepted";
+        rejected: "rejected";
+        inconclusive: "inconclusive";
+        launch_failed: "launch_failed";
+        quarantined: "quarantined";
     }>;
-    /**
-     * Get check runs for a commit SHA
-     */
-    getCheckRuns(sha: string): Promise<{
-        total_count: number;
-        check_runs: Array<{
-            status: string;
-            conclusion: string | null;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    completed_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type Attempt_v1 = z.infer<typeof Attempt_v1>;
+declare const AttemptRetryDeltaDimension_v1: z.ZodEnum<{
+    strategy: "strategy";
+    environment: "environment";
+    evidence: "evidence";
+    premise: "premise";
+    inputs: "inputs";
+    authority: "authority";
+    worker_runtime: "worker_runtime";
+}>;
+type AttemptRetryDeltaDimension_v1 = z.infer<typeof AttemptRetryDeltaDimension_v1>;
+/** Immutable fail-forward justification for creating a later Attempt. */
+declare const AttemptRetryDelta_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    previous_attempt_id: z.ZodString;
+    next_attempt_id: z.ZodString;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    changes: z.ZodArray<z.ZodObject<{
+        dimension: z.ZodEnum<{
+            strategy: "strategy";
+            environment: "environment";
+            evidence: "evidence";
+            premise: "premise";
+            inputs: "inputs";
+            authority: "authority";
+            worker_runtime: "worker_runtime";
         }>;
+        before_hash: z.ZodString;
+        after_hash: z.ZodString;
+    }, z.core.$strict>>;
+    inherited_evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            verification: "verification";
+            receipt: "receipt";
+            fan_in_decision: "fan_in_decision";
+            artifact: "artifact";
+            observation: "observation";
+            deviation: "deviation";
+        }>;
+        id: z.ZodString;
+        hash: z.ZodString;
+    }, z.core.$strict>>;
+    policy_exception: z.ZodOptional<z.ZodObject<{
+        policy_id: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    summary: z.ZodString;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+type AttemptRetryDelta_v1 = z.infer<typeof AttemptRetryDelta_v1>;
+declare const FanoutRationale_v1: z.ZodEnum<{
+    separable_work: "separable_work";
+    hypothesis_diversity: "hypothesis_diversity";
+    independent_review: "independent_review";
+    risk_reduction: "risk_reduction";
+    best_of_n: "best_of_n";
+}>;
+type FanoutRationale_v1 = z.infer<typeof FanoutRationale_v1>;
+declare const FanoutSelectionCriterion_v1: z.ZodEnum<{
+    verification_outcome: "verification_outcome";
+    trust_gap_count: "trust_gap_count";
+    verified_result_identity: "verified_result_identity";
+}>;
+type FanoutSelectionCriterion_v1 = z.infer<typeof FanoutSelectionCriterion_v1>;
+declare const STRICT_FANOUT_SELECTION_CRITERIA: readonly ["verification_outcome", "trust_gap_count", "verified_result_identity"];
+declare const FanoutPremise_v1: z.ZodObject<{
+    premise_id: z.ZodString;
+    attempt_id: z.ZodString;
+    strategy_hash: z.ZodString;
+    summary: z.ZodString;
+}, z.core.$strict>;
+type FanoutPremise_v1 = z.infer<typeof FanoutPremise_v1>;
+/** Immutable one-level fanout declaration. It is scheduling intent, not acceptance truth. */
+declare const AgentWorkFanoutPlan_v1: z.ZodPipe<z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    fanout_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    rationale: z.ZodEnum<{
+        separable_work: "separable_work";
+        hypothesis_diversity: "hypothesis_diversity";
+        independent_review: "independent_review";
+        risk_reduction: "risk_reduction";
+        best_of_n: "best_of_n";
     }>;
-    /**
-     * Get reviews for a pull request
-     */
-    getReviews(prNumber: number): Promise<Array<{
-        user: {
-            login: string;
-        } | null;
-        state: string;
+    selection_criteria: z.ZodArray<z.ZodEnum<{
+        verification_outcome: "verification_outcome";
+        trust_gap_count: "trust_gap_count";
+        verified_result_identity: "verified_result_identity";
     }>>;
-    /**
-     * Compare two commits
-     */
-    compare(base: string, head: string): Promise<{
-        merge_base_commit?: {
-            sha: string;
-        };
+    budget: z.ZodObject<{
+        max_attempts: z.ZodNumber;
+        max_concurrency: z.ZodNumber;
+        max_elapsed_ms: z.ZodNumber;
+        max_context_bytes_per_attempt: z.ZodNumber;
+        max_judging_cost_units: z.ZodNumber;
+    }, z.core.$strict>;
+    premises: z.ZodArray<z.ZodObject<{
+        premise_id: z.ZodString;
+        attempt_id: z.ZodString;
+        strategy_hash: z.ZodString;
+        summary: z.ZodString;
+    }, z.core.$strict>>;
+    direct_worker_communication: z.ZodEnum<{
+        forbidden: "forbidden";
+        brokered: "brokered";
     }>;
-    /**
-     * List issues (excluding PRs if filtered by caller)
-     */
-    listIssues(options: {
-        state: "open" | "closed" | "all";
-    }): Promise<any[]>;
-    /**
-     * Update a pull request's branch with the latest changes from the base branch
-     * This is typically used after merging another PR to keep branches up to date
-     */
-    updatePullRequestBranch(owner: string, repo: string, prNumber: number): Promise<void>;
-    /**
-     * Merge a pull request
-     */
-    mergePullRequest(owner: string, repo: string, prNumber: number, options: {
-        method: "squash" | "merge" | "rebase";
-        commitTitle?: string;
-    }): Promise<boolean>;
-    /**
-     * Get commit status for a SHA
-     */
-    getCommitStatus(owner: string, repo: string, ref: string): Promise<{
-        state: string;
-        statuses: any[];
+    created_at: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    selection_criteria: ("verification_outcome" | "trust_gap_count" | "verified_result_identity")[];
+    premises: {
+        premise_id: string;
+        attempt_id: string;
+        strategy_hash: string;
+        summary: string;
+    }[];
+    schema_version: "1.0.0";
+    fanout_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    rationale: "separable_work" | "hypothesis_diversity" | "independent_review" | "risk_reduction" | "best_of_n";
+    budget: {
+        max_attempts: number;
+        max_concurrency: number;
+        max_elapsed_ms: number;
+        max_context_bytes_per_attempt: number;
+        max_judging_cost_units: number;
+    };
+    direct_worker_communication: "forbidden" | "brokered";
+    created_at: string;
+}, {
+    schema_version: "1.0.0";
+    fanout_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    rationale: "separable_work" | "hypothesis_diversity" | "independent_review" | "risk_reduction" | "best_of_n";
+    selection_criteria: ("verification_outcome" | "trust_gap_count" | "verified_result_identity")[];
+    budget: {
+        max_attempts: number;
+        max_concurrency: number;
+        max_elapsed_ms: number;
+        max_context_bytes_per_attempt: number;
+        max_judging_cost_units: number;
+    };
+    premises: {
+        premise_id: string;
+        attempt_id: string;
+        strategy_hash: string;
+        summary: string;
+    }[];
+    direct_worker_communication: "forbidden" | "brokered";
+    created_at: string;
+}>>;
+type AgentWorkFanoutPlan_v1 = z.infer<typeof AgentWorkFanoutPlan_v1>;
+/** Exact plan slot persisted atomically with a sibling Attempt. */
+declare const FanoutAttemptBinding_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    fanout_id: z.ZodString;
+    fanout_plan_hash: z.ZodString;
+    premise_id: z.ZodString;
+    premise_hash: z.ZodString;
+    attempt_id: z.ZodString;
+}, z.core.$strict>;
+type FanoutAttemptBinding_v1 = z.infer<typeof FanoutAttemptBinding_v1>;
+declare const FanInCandidateConclusion_v1: z.ZodEnum<{
+    rejected: "rejected";
+    selected: "selected";
+    equivalent: "equivalent";
+    unselected: "unselected";
+    missing_evidence: "missing_evidence";
+}>;
+type FanInCandidateConclusion_v1 = z.infer<typeof FanInCandidateConclusion_v1>;
+/** Engine-owned deterministic comparison of a complete bounded fanout evidence set. */
+declare const AgentWorkFanInDecision_v1: z.ZodPipe<z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    decision_id: z.ZodString;
+    fanout_id: z.ZodString;
+    fanout_plan_hash: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    policy_id: z.ZodLiteral<"lexrunner.engine-fanin.strict">;
+    policy_version: z.ZodLiteral<"1.0.0">;
+    selection_criteria: z.ZodArray<z.ZodEnum<{
+        verification_outcome: "verification_outcome";
+        trust_gap_count: "trust_gap_count";
+        verified_result_identity: "verified_result_identity";
+    }>>;
+    decision: z.ZodEnum<{
+        escalated: "escalated";
+        selected: "selected";
+        no_viable_candidate: "no_viable_candidate";
     }>;
-}
-/**
- * Create GitHub API client from environment and config
- */
-declare function createGitHubAPI(): Promise<GitHubAPI | null>;
-
-/**
- * GitHub API integration types
- * Defines data structures for PR metadata and repository information
- */
-interface RepositoryInfo {
-    owner: string;
-    repo: string;
-    defaultBranch: string;
-    url: string;
-}
-interface PullRequest {
+    selected_attempt_id: z.ZodOptional<z.ZodString>;
+    candidates: z.ZodArray<z.ZodObject<{
+        attempt_id: z.ZodString;
+        premise_id: z.ZodString;
+        attempt_status: z.ZodEnum<{
+            blocked: "blocked";
+            verifying: "verifying";
+            verified: "verified";
+            failed: "failed";
+            cancelled: "cancelled";
+            prepared: "prepared";
+            leased: "leased";
+            launching: "launching";
+            running: "running";
+            receipt_submitted: "receipt_submitted";
+            accepted: "accepted";
+            rejected: "rejected";
+            inconclusive: "inconclusive";
+            launch_failed: "launch_failed";
+            quarantined: "quarantined";
+        }>;
+        receipt_id: z.ZodOptional<z.ZodString>;
+        receipt_hash: z.ZodOptional<z.ZodString>;
+        verification_id: z.ZodOptional<z.ZodString>;
+        verification_hash: z.ZodOptional<z.ZodString>;
+        verification_outcome: z.ZodOptional<z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            cancelled: "cancelled";
+            inconclusive: "inconclusive";
+            infrastructure_error: "infrastructure_error";
+        }>>;
+        verified_result_identity: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        trust_gap_count: z.ZodNumber;
+        conclusion: z.ZodEnum<{
+            rejected: "rejected";
+            selected: "selected";
+            equivalent: "equivalent";
+            unselected: "unselected";
+            missing_evidence: "missing_evidence";
+        }>;
+        reason_codes: z.ZodArray<z.ZodString>;
+        artifact_refs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    conflicts: z.ZodArray<z.ZodString>;
+    uncertainty: z.ZodArray<z.ZodString>;
+    evidence_set_hash: z.ZodString;
+    summary: z.ZodString;
+    created_at: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    selection_criteria: ("verification_outcome" | "trust_gap_count" | "verified_result_identity")[];
+    candidates: {
+        attempt_id: string;
+        premise_id: string;
+        attempt_status: "blocked" | "verifying" | "verified" | "failed" | "cancelled" | "prepared" | "leased" | "launching" | "running" | "receipt_submitted" | "accepted" | "rejected" | "inconclusive" | "launch_failed" | "quarantined";
+        trust_gap_count: number;
+        conclusion: "rejected" | "selected" | "equivalent" | "unselected" | "missing_evidence";
+        reason_codes: string[];
+        artifact_refs: string[];
+        receipt_id?: string | undefined;
+        receipt_hash?: string | undefined;
+        verification_id?: string | undefined;
+        verification_hash?: string | undefined;
+        verification_outcome?: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error" | undefined;
+        verified_result_identity?: string | undefined;
+    }[];
+    conflicts: string[];
+    uncertainty: string[];
+    schema_version: "1.0.0";
+    decision_id: string;
+    fanout_id: string;
+    fanout_plan_hash: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    policy_id: "lexrunner.engine-fanin.strict";
+    policy_version: "1.0.0";
+    decision: "escalated" | "selected" | "no_viable_candidate";
+    evidence_set_hash: string;
+    summary: string;
+    created_at: string;
+    selected_attempt_id?: string | undefined;
+}, {
+    schema_version: "1.0.0";
+    decision_id: string;
+    fanout_id: string;
+    fanout_plan_hash: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    policy_id: "lexrunner.engine-fanin.strict";
+    policy_version: "1.0.0";
+    selection_criteria: ("verification_outcome" | "trust_gap_count" | "verified_result_identity")[];
+    decision: "escalated" | "selected" | "no_viable_candidate";
+    candidates: {
+        attempt_id: string;
+        premise_id: string;
+        attempt_status: "blocked" | "verifying" | "verified" | "failed" | "cancelled" | "prepared" | "leased" | "launching" | "running" | "receipt_submitted" | "accepted" | "rejected" | "inconclusive" | "launch_failed" | "quarantined";
+        trust_gap_count: number;
+        conclusion: "rejected" | "selected" | "equivalent" | "unselected" | "missing_evidence";
+        reason_codes: string[];
+        artifact_refs: string[];
+        receipt_id?: string | undefined;
+        receipt_hash?: string | undefined;
+        verification_id?: string | undefined;
+        verification_hash?: string | undefined;
+        verification_outcome?: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error" | undefined;
+        verified_result_identity?: string | undefined;
+    }[];
+    conflicts: string[];
+    uncertainty: string[];
+    evidence_set_hash: string;
+    summary: string;
+    created_at: string;
+    selected_attempt_id?: string | undefined;
+}>>;
+type AgentWorkFanInDecision_v1 = z.infer<typeof AgentWorkFanInDecision_v1>;
+declare function computeFanInEvidenceSetHash(candidates: AgentWorkFanInDecision_v1["candidates"]): string;
+/** Portable packet content before LexRunner derives and verifies packet_hash. */
+declare const AgentTaskPacketHashInput_v1: z.ZodObject<{
+    objective: z.ZodString;
+    run_id: z.ZodString;
+    created_at: z.ZodString;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        remote_url: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+        base_sha: z.ZodString;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        read_globs: z.ZodArray<z.ZodString>;
+        write_globs: z.ZodArray<z.ZodString>;
+        deny_globs: z.ZodArray<z.ZodString>;
+        cross_repo_allowed: z.ZodBoolean;
+    }, z.core.$strict>;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    budget: z.ZodObject<{
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_tool_calls: z.ZodOptional<z.ZodNumber>;
+        max_elapsed_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    verification: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        cwd_rel: z.ZodOptional<z.ZodString>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        expected_exit_codes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    authority: z.ZodObject<{
+        edit: z.ZodBoolean;
+        git_write: z.ZodBoolean;
+        github_write: z.ZodBoolean;
+        external_runtime: z.ZodBoolean;
+        secrets: z.ZodBoolean;
+        signing: z.ZodBoolean;
+        release: z.ZodBoolean;
+    }, z.core.$strict>;
+    work_item: z.ZodObject<{
+        work_item_id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    instructions: z.ZodArray<z.ZodString>;
+    preparation: z.ZodOptional<z.ZodObject<{
+        policy: z.ZodObject<{
+            network: z.ZodEnum<{
+                forbidden: "forbidden";
+                registry_only: "registry_only";
+            }>;
+            registries: z.ZodArray<z.ZodString>;
+            cache: z.ZodEnum<{
+                disabled: "disabled";
+                read_only: "read_only";
+                read_write: "read_write";
+            }>;
+            lifecycle_scripts: z.ZodEnum<{
+                allowed: "allowed";
+                forbidden: "forbidden";
+            }>;
+        }, z.core.$strict>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                build: "build";
+                provision: "provision";
+            }>;
+            argv: z.ZodArray<z.ZodString>;
+            cwd_rel: z.ZodOptional<z.ZodString>;
+            depends_on: z.ZodArray<z.ZodString>;
+            expected_exit_codes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const AgentTaskPacket_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    packet_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item: z.ZodObject<{
+        work_item_id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    attempt_id: z.ZodString;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        remote_url: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+        base_sha: z.ZodString;
+    }, z.core.$strict>;
+    objective: z.ZodString;
+    acceptance_criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    instructions: z.ZodArray<z.ZodString>;
+    scope: z.ZodObject<{
+        read_globs: z.ZodArray<z.ZodString>;
+        write_globs: z.ZodArray<z.ZodString>;
+        deny_globs: z.ZodArray<z.ZodString>;
+        cross_repo_allowed: z.ZodBoolean;
+    }, z.core.$strict>;
+    authority: z.ZodObject<{
+        edit: z.ZodBoolean;
+        git_write: z.ZodBoolean;
+        github_write: z.ZodBoolean;
+        external_runtime: z.ZodBoolean;
+        secrets: z.ZodBoolean;
+        signing: z.ZodBoolean;
+        release: z.ZodBoolean;
+    }, z.core.$strict>;
+    preparation: z.ZodOptional<z.ZodObject<{
+        policy: z.ZodObject<{
+            network: z.ZodEnum<{
+                forbidden: "forbidden";
+                registry_only: "registry_only";
+            }>;
+            registries: z.ZodArray<z.ZodString>;
+            cache: z.ZodEnum<{
+                disabled: "disabled";
+                read_only: "read_only";
+                read_write: "read_write";
+            }>;
+            lifecycle_scripts: z.ZodEnum<{
+                allowed: "allowed";
+                forbidden: "forbidden";
+            }>;
+        }, z.core.$strict>;
+        steps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                build: "build";
+                provision: "provision";
+            }>;
+            argv: z.ZodArray<z.ZodString>;
+            cwd_rel: z.ZodOptional<z.ZodString>;
+            depends_on: z.ZodArray<z.ZodString>;
+            expected_exit_codes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    verification: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        cwd_rel: z.ZodOptional<z.ZodString>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        expected_exit_codes: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>>;
+    budget: z.ZodObject<{
+        max_tokens: z.ZodOptional<z.ZodNumber>;
+        max_tool_calls: z.ZodOptional<z.ZodNumber>;
+        max_elapsed_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    created_at: z.ZodString;
+    packet_hash: z.ZodString;
+}, z.core.$strict>;
+type AgentTaskPacket_v1 = z.infer<typeof AgentTaskPacket_v1>;
+type AgentTaskPacketHashInput = z.infer<typeof AgentTaskPacketHashInput_v1>;
+declare function computeAgentTaskPacketHash(packet: AgentTaskPacketHashInput): string;
+declare function createAgentTaskPacket(packet: AgentTaskPacketHashInput): AgentTaskPacket_v1;
+declare const AgentWorkPreparationReceipt_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    receipt_id: z.ZodString;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    preparation_plan_hash: z.ZodString;
+    policy_hash: z.ZodString;
+    outcome: z.ZodEnum<{
+        failed: "failed";
+        passed: "passed";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodEnum<{
+            blocked: "blocked";
+            failed: "failed";
+            passed: "passed";
+        }>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        stdout_hash: z.ZodOptional<z.ZodString>;
+        stderr_hash: z.ZodOptional<z.ZodString>;
+        policy_hash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    started_at: z.ZodString;
+    completed_at: z.ZodString;
+    receipt_hash: z.ZodString;
+}, z.core.$strict>;
+type AgentWorkPreparationReceipt_v1 = z.infer<typeof AgentWorkPreparationReceipt_v1>;
+declare const ExecutionEnvironmentOS: z.ZodEnum<{
+    darwin: "darwin";
+    linux: "linux";
+    other: "other";
+    windows: "windows";
+}>;
+type ExecutionEnvironmentOS = z.infer<typeof ExecutionEnvironmentOS>;
+declare const ExecutionEnvelope_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    envelope_id: z.ZodString;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    expected_head_sha: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    runtime: z.ZodObject<{
+        host_id: z.ZodString;
+        os: z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+            other: "other";
+            windows: "windows";
+        }>;
+        architecture: z.ZodString;
+        worker_runtime: z.ZodString;
+        git_runtime: z.ZodString;
+    }, z.core.$strict>;
+    paths: z.ZodObject<{
+        project_root: z.ZodString;
+        execution_root: z.ZodString;
+        worktree_root: z.ZodString;
+    }, z.core.$strict>;
+    path_mappings: z.ZodArray<z.ZodObject<{
+        runtime: z.ZodString;
+        worktree_root: z.ZodString;
+    }, z.core.$strict>>;
+    exposed_environment_keys: z.ZodArray<z.ZodString>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+type ExecutionEnvelope_v1 = z.infer<typeof ExecutionEnvelope_v1>;
+declare const ControllerLease_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    lease_id: z.ZodString;
+    run_id: z.ZodString;
+    controller_id: z.ZodString;
+    control_mode: z.ZodEnum<{
+        assisted: "assisted";
+        headless: "headless";
+    }>;
+    fence: z.ZodNumber;
+    revision: z.ZodNumber;
+    run_revision: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        released: "released";
+        expired: "expired";
+        revoked: "revoked";
+    }>;
+    acquired_at: z.ZodString;
+    heartbeat_at: z.ZodString;
+    expires_at: z.ZodString;
+    released_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ControllerLease_v1 = z.infer<typeof ControllerLease_v1>;
+declare const WorkspaceLeaseStatus: z.ZodEnum<{
+    verifying: "verifying";
+    active: "active";
+    receipt_submitted: "receipt_submitted";
+    quarantined: "quarantined";
+    released: "released";
+    expired: "expired";
+    reserved: "reserved";
+    acquired: "acquired";
+    preserved: "preserved";
+    abandoned: "abandoned";
+}>;
+type WorkspaceLeaseStatus = z.infer<typeof WorkspaceLeaseStatus>;
+declare const WorkspaceCleanupDisposition: z.ZodEnum<{
+    preserved: "preserved";
+    abandoned: "abandoned";
+    integrated: "integrated";
+    discarded: "discarded";
+}>;
+type WorkspaceCleanupDisposition = z.infer<typeof WorkspaceCleanupDisposition>;
+declare const WorkspaceLease_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    lease_id: z.ZodString;
+    revision: z.ZodNumber;
+    run_id: z.ZodString;
+    run_revision: z.ZodNumber;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    attempt_id: z.ZodString;
+    controller_lease_id: z.ZodString;
+    controller_fence: z.ZodNumber;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        remote_url: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    base_sha: z.ZodString;
+    branch: z.ZodString;
+    scope: z.ZodObject<{
+        read_globs: z.ZodArray<z.ZodString>;
+        write_globs: z.ZodArray<z.ZodString>;
+        deny_globs: z.ZodArray<z.ZodString>;
+        cross_repo_allowed: z.ZodBoolean;
+    }, z.core.$strict>;
+    authority: z.ZodObject<{
+        edit: z.ZodBoolean;
+        git_write: z.ZodBoolean;
+        github_write: z.ZodBoolean;
+        external_runtime: z.ZodBoolean;
+        secrets: z.ZodBoolean;
+        signing: z.ZodBoolean;
+        release: z.ZodBoolean;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        verifying: "verifying";
+        active: "active";
+        receipt_submitted: "receipt_submitted";
+        quarantined: "quarantined";
+        released: "released";
+        expired: "expired";
+        reserved: "reserved";
+        acquired: "acquired";
+        preserved: "preserved";
+        abandoned: "abandoned";
+    }>;
+    acquired_at: z.ZodString;
+    heartbeat_at: z.ZodString;
+    expires_at: z.ZodString;
+    released_at: z.ZodOptional<z.ZodString>;
+    cleanup_disposition: z.ZodOptional<z.ZodEnum<{
+        preserved: "preserved";
+        abandoned: "abandoned";
+        integrated: "integrated";
+        discarded: "discarded";
+    }>>;
+}, z.core.$strict>;
+type WorkspaceLease_v1 = z.infer<typeof WorkspaceLease_v1>;
+declare const WorkspaceAllocationStatus: z.ZodEnum<{
+    active: "active";
+    quarantined: "quarantined";
+    released: "released";
+    allocated: "allocated";
+}>;
+type WorkspaceAllocationStatus = z.infer<typeof WorkspaceAllocationStatus>;
+declare const WorkspaceAllocation_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    allocation_id: z.ZodString;
+    revision: z.ZodNumber;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    repository: z.ZodObject<{
+        id: z.ZodString;
+        remote_url: z.ZodOptional<z.ZodString>;
+        default_branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    base_sha: z.ZodString;
+    branch: z.ZodString;
+    host_id: z.ZodString;
+    git_runtime: z.ZodString;
+    paths: z.ZodObject<{
+        project_root: z.ZodString;
+        worktree_root: z.ZodString;
+        repository_git_common_dir: z.ZodString;
+        worktree_git_dir: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        active: "active";
+        quarantined: "quarantined";
+        released: "released";
+        allocated: "allocated";
+    }>;
+    observation: z.ZodOptional<z.ZodObject<{
+        registration: z.ZodEnum<{
+            missing: "missing";
+            registered: "registered";
+            unregistered: "unregistered";
+            wrong_repository: "wrong_repository";
+            wrong_branch: "wrong_branch";
+        }>;
+        cleanliness: z.ZodEnum<{
+            unknown: "unknown";
+            clean: "clean";
+            dirty: "dirty";
+        }>;
+        observed_branch: z.ZodOptional<z.ZodString>;
+        observed_head_sha: z.ZodOptional<z.ZodString>;
+        observed_at: z.ZodString;
+    }, z.core.$strict>>;
+    quarantine_reason: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        missing: "missing";
+        dirty: "dirty";
+        expired: "expired";
+        unregistered: "unregistered";
+        wrong_repository: "wrong_repository";
+        wrong_branch: "wrong_branch";
+        identity_ambiguous: "identity_ambiguous";
+    }>>;
+    quarantine_evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allocated_at: z.ZodString;
+    updated_at: z.ZodString;
+    released_at: z.ZodOptional<z.ZodString>;
+    quarantined_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type WorkspaceAllocation_v1 = z.infer<typeof WorkspaceAllocation_v1>;
+declare const WorkerSessionBackend: z.ZodEnum<{
+    external: "external";
+    "host-subagent": "host-subagent";
+    "codex-cli": "codex-cli";
+}>;
+type WorkerSessionBackend = z.infer<typeof WorkerSessionBackend>;
+declare const WorkerSessionStatus: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    awaiting_human: "awaiting_human";
+    running: "running";
+    starting: "starting";
+    lost: "lost";
+}>;
+type WorkerSessionStatus = z.infer<typeof WorkerSessionStatus>;
+declare const WorkerSession_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    session_id: z.ZodString;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    execution_envelope_id: z.ZodString;
+    worker: z.ZodObject<{
+        backend: z.ZodEnum<{
+            external: "external";
+            "host-subagent": "host-subagent";
+            "codex-cli": "codex-cli";
+        }>;
+        worker_id: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        awaiting_human: "awaiting_human";
+        running: "running";
+        starting: "starting";
+        lost: "lost";
+    }>;
+    started_at: z.ZodString;
+    heartbeat_at: z.ZodString;
+    ended_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type WorkerSession_v1 = z.infer<typeof WorkerSession_v1>;
+declare const ClaimedCheckOutcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    not_run: "not_run";
+}>;
+type ClaimedCheckOutcome = z.infer<typeof ClaimedCheckOutcome>;
+declare const AgentTaskReceiptOutcome: z.ZodEnum<{
+    blocked: "blocked";
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+type AgentTaskReceiptOutcome = z.infer<typeof AgentTaskReceiptOutcome>;
+declare const AgentTaskReceipt_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    receipt_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    worker_session_id: z.ZodString;
+    base_sha: z.ZodString;
+    final_head_sha: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    summary: z.ZodString;
+    files_touched: z.ZodArray<z.ZodString>;
+    commits: z.ZodArray<z.ZodString>;
+    acceptance_criteria_addressed: z.ZodArray<z.ZodString>;
+    claimed_checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            not_run: "not_run";
+        }>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        output_snippet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    assumptions: z.ZodArray<z.ZodString>;
+    blockers: z.ZodArray<z.ZodString>;
+    human_action_request_ids: z.ZodArray<z.ZodString>;
+    cost: z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        tool_calls: z.ZodOptional<z.ZodNumber>;
+        elapsed_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    submitted_at: z.ZodString;
+}, z.core.$strict>;
+type AgentTaskReceipt_v1 = z.infer<typeof AgentTaskReceipt_v1>;
+/**
+ * Complete general-work receipt claim for durable ingestion.
+ *
+ * Every result carries a content identity even when the coordinator, rather
+ * than the worker, owns Git commits. Claimed checks and result hashes remain
+ * worker assertions; only AgentEngineVerification may establish truth.
+ */
+declare const AgentTaskReceipt_v2: z.ZodPipe<z.ZodObject<{
+    schema_version: z.ZodLiteral<"2.0.0">;
+    receipt_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    worker_runtime: z.ZodString;
+    worker_session_id: z.ZodString;
+    observed_base_sha: z.ZodString;
+    final_head_sha: z.ZodOptional<z.ZodString>;
+    patch_hash: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    exit_reason: z.ZodString;
+    summary: z.ZodString;
+    files_touched: z.ZodArray<z.ZodString>;
+    commits: z.ZodArray<z.ZodString>;
+    acceptance_criteria_addressed: z.ZodArray<z.ZodString>;
+    claimed_checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            not_run: "not_run";
+        }>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        output_snippet: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    assumptions: z.ZodArray<z.ZodString>;
+    blockers: z.ZodArray<z.ZodString>;
+    human_action_request_ids: z.ZodArray<z.ZodString>;
+    cost: z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        tool_calls: z.ZodOptional<z.ZodNumber>;
+        elapsed_ms: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    worker_started_at: z.ZodString;
+    worker_completed_at: z.ZodString;
+    submitted_at: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    files_touched: string[];
+    acceptance_criteria_addressed: string[];
+    claimed_checks: {
+        id: string;
+        outcome: "pass" | "fail" | "not_run";
+        exit_code?: number | undefined;
+        output_snippet?: string | undefined;
+    }[];
+    assumptions: string[];
+    blockers: string[];
+    human_action_request_ids: string[];
+    schema_version: "2.0.0";
+    receipt_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    attempt_id: string;
+    packet_id: string;
+    packet_hash: string;
+    workspace_lease_id: string;
+    workspace_lease_revision: number;
+    worker_runtime: string;
+    worker_session_id: string;
+    observed_base_sha: string;
+    outcome: "blocked" | "completed" | "failed" | "cancelled";
+    exit_reason: string;
+    summary: string;
+    commits: string[];
+    cost: {
+        input_tokens?: number | undefined;
+        output_tokens?: number | undefined;
+        tool_calls?: number | undefined;
+        elapsed_ms?: number | undefined;
+    };
+    worker_started_at: string;
+    worker_completed_at: string;
+    submitted_at: string;
+    final_head_sha?: string | undefined;
+    patch_hash?: string | undefined;
+}, {
+    schema_version: "2.0.0";
+    receipt_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    attempt_id: string;
+    packet_id: string;
+    packet_hash: string;
+    workspace_lease_id: string;
+    workspace_lease_revision: number;
+    worker_runtime: string;
+    worker_session_id: string;
+    observed_base_sha: string;
+    outcome: "blocked" | "completed" | "failed" | "cancelled";
+    exit_reason: string;
+    summary: string;
+    files_touched: string[];
+    commits: string[];
+    acceptance_criteria_addressed: string[];
+    claimed_checks: {
+        id: string;
+        outcome: "pass" | "fail" | "not_run";
+        exit_code?: number | undefined;
+        output_snippet?: string | undefined;
+    }[];
+    assumptions: string[];
+    blockers: string[];
+    human_action_request_ids: string[];
+    cost: {
+        input_tokens?: number | undefined;
+        output_tokens?: number | undefined;
+        tool_calls?: number | undefined;
+        elapsed_ms?: number | undefined;
+    };
+    worker_started_at: string;
+    worker_completed_at: string;
+    submitted_at: string;
+    final_head_sha?: string | undefined;
+    patch_hash?: string | undefined;
+}>>;
+type AgentTaskReceipt_v2 = z.infer<typeof AgentTaskReceipt_v2>;
+/**
+ * Validate set membership that only the authoritative packet snapshot can establish.
+ *
+ * AgentTaskReceipt_v2 has no extra-check lane: every claimed check must name one
+ * packet-declared verification. A future extra-check lane requires a versioned
+ * contract rather than overloading the declared-check namespace.
+ */
+declare function validateAgentTaskReceiptV2PacketReferences(packet: AgentTaskPacket_v1, receipt: AgentTaskReceipt_v2): {
+    valid: boolean;
+    errors: string[];
+};
+declare const VerificationOutcome: z.ZodEnum<{
+    pass: "pass";
+    fail: "fail";
+    cancelled: "cancelled";
+    inconclusive: "inconclusive";
+    infrastructure_error: "infrastructure_error";
+}>;
+type VerificationOutcome = z.infer<typeof VerificationOutcome>;
+declare const AgentEngineVerification_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    verification_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    worker_session_id: z.ZodString;
+    receipt_id: z.ZodString;
+    receipt_hash: z.ZodString;
+    base_sha: z.ZodString;
+    verified_head_sha: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        cancelled: "cancelled";
+        inconclusive: "inconclusive";
+        infrastructure_error: "infrastructure_error";
+    }>;
+    summary: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            cancelled: "cancelled";
+            inconclusive: "inconclusive";
+            infrastructure_error: "infrastructure_error";
+        }>;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        stdout_snippet: z.ZodOptional<z.ZodString>;
+        stderr_snippet: z.ZodOptional<z.ZodString>;
+        artifact_refs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    failures: z.ZodArray<z.ZodString>;
+    trust_gap: z.ZodBoolean;
+    verifier_id: z.ZodString;
+    started_at: z.ZodString;
+    completed_at: z.ZodString;
+}, z.core.$strict>;
+type AgentEngineVerification_v1 = z.infer<typeof AgentEngineVerification_v1>;
+declare const EngineVerificationCheckSource_v2: z.ZodEnum<{
+    packet: "packet";
+    engine_extra: "engine_extra";
+}>;
+type EngineVerificationCheckSource_v2 = z.infer<typeof EngineVerificationCheckSource_v2>;
+declare const EngineVerificationDeterminism_v2: z.ZodEnum<{
+    unknown: "unknown";
+    deterministic: "deterministic";
+    externally_nondeterministic: "externally_nondeterministic";
+}>;
+type EngineVerificationDeterminism_v2 = z.infer<typeof EngineVerificationDeterminism_v2>;
+declare const EngineVerificationTrustGapReason_v2: z.ZodEnum<{
+    worker_outcome_disagrees: "worker_outcome_disagrees";
+    head_identity_disagrees: "head_identity_disagrees";
+    patch_identity_disagrees: "patch_identity_disagrees";
+    claimed_check_disagrees: "claimed_check_disagrees";
+    authority_deviation: "authority_deviation";
+}>;
+type EngineVerificationTrustGapReason_v2 = z.infer<typeof EngineVerificationTrustGapReason_v2>;
+/** Immutable engine-observed evidence for one durable AgentTaskReceipt v2. */
+declare const AgentEngineVerification_v2: z.ZodPipe<z.ZodObject<{
+    schema_version: z.ZodLiteral<"2.0.0">;
+    verification_id: z.ZodString;
+    run_id: z.ZodString;
+    work_item_id: z.ZodString;
+    work_item_revision: z.ZodNumber;
+    attempt_id: z.ZodString;
+    packet_id: z.ZodString;
+    packet_hash: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    workspace_lease_revision: z.ZodNumber;
+    worker_session_id: z.ZodString;
+    worker_session_revision: z.ZodNumber;
+    receipt_id: z.ZodString;
+    receipt_hash: z.ZodString;
+    observed_base_sha: z.ZodString;
+    verified_head_sha: z.ZodOptional<z.ZodString>;
+    verified_patch_hash: z.ZodOptional<z.ZodString>;
+    workspace_observation_hash: z.ZodString;
+    outcome: z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        cancelled: "cancelled";
+        inconclusive: "inconclusive";
+        infrastructure_error: "infrastructure_error";
+    }>;
+    summary: z.ZodString;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodEnum<{
+            packet: "packet";
+            engine_extra: "engine_extra";
+        }>;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            cancelled: "cancelled";
+            inconclusive: "inconclusive";
+            infrastructure_error: "infrastructure_error";
+        }>;
+        command_hash: z.ZodString;
+        cwd_rel: z.ZodOptional<z.ZodString>;
+        environment_fingerprint: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNumber>;
+        stdout_hash: z.ZodOptional<z.ZodString>;
+        stderr_hash: z.ZodOptional<z.ZodString>;
+        stdout_snippet: z.ZodOptional<z.ZodString>;
+        stderr_snippet: z.ZodOptional<z.ZodString>;
+        duration_ms: z.ZodNumber;
+        retry_count: z.ZodNumber;
+        artifact_refs: z.ZodArray<z.ZodString>;
+        determinism: z.ZodEnum<{
+            unknown: "unknown";
+            deterministic: "deterministic";
+            externally_nondeterministic: "externally_nondeterministic";
+        }>;
+    }, z.core.$strict>>;
+    failures: z.ZodArray<z.ZodString>;
+    trust_gap_reasons: z.ZodArray<z.ZodEnum<{
+        worker_outcome_disagrees: "worker_outcome_disagrees";
+        head_identity_disagrees: "head_identity_disagrees";
+        patch_identity_disagrees: "patch_identity_disagrees";
+        claimed_check_disagrees: "claimed_check_disagrees";
+        authority_deviation: "authority_deviation";
+    }>>;
+    verifier_id: z.ZodString;
+    verifier_version: z.ZodString;
+    started_at: z.ZodString;
+    completed_at: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    checks: {
+        artifact_refs: string[];
+        id: string;
+        source: "packet" | "engine_extra";
+        outcome: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error";
+        command_hash: string;
+        environment_fingerprint: string;
+        duration_ms: number;
+        retry_count: number;
+        determinism: "unknown" | "deterministic" | "externally_nondeterministic";
+        cwd_rel?: string | undefined;
+        exit_code?: number | undefined;
+        stdout_hash?: string | undefined;
+        stderr_hash?: string | undefined;
+        stdout_snippet?: string | undefined;
+        stderr_snippet?: string | undefined;
+    }[];
+    failures: string[];
+    trust_gap_reasons: ("worker_outcome_disagrees" | "head_identity_disagrees" | "patch_identity_disagrees" | "claimed_check_disagrees" | "authority_deviation")[];
+    schema_version: "2.0.0";
+    verification_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    attempt_id: string;
+    packet_id: string;
+    packet_hash: string;
+    workspace_lease_id: string;
+    workspace_lease_revision: number;
+    worker_session_id: string;
+    worker_session_revision: number;
+    receipt_id: string;
+    receipt_hash: string;
+    observed_base_sha: string;
+    workspace_observation_hash: string;
+    outcome: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error";
+    summary: string;
+    verifier_id: string;
+    verifier_version: string;
+    started_at: string;
+    completed_at: string;
+    verified_head_sha?: string | undefined;
+    verified_patch_hash?: string | undefined;
+}, {
+    schema_version: "2.0.0";
+    verification_id: string;
+    run_id: string;
+    work_item_id: string;
+    work_item_revision: number;
+    attempt_id: string;
+    packet_id: string;
+    packet_hash: string;
+    workspace_lease_id: string;
+    workspace_lease_revision: number;
+    worker_session_id: string;
+    worker_session_revision: number;
+    receipt_id: string;
+    receipt_hash: string;
+    observed_base_sha: string;
+    workspace_observation_hash: string;
+    outcome: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error";
+    summary: string;
+    checks: {
+        id: string;
+        source: "packet" | "engine_extra";
+        outcome: "pass" | "fail" | "cancelled" | "inconclusive" | "infrastructure_error";
+        command_hash: string;
+        environment_fingerprint: string;
+        duration_ms: number;
+        retry_count: number;
+        artifact_refs: string[];
+        determinism: "unknown" | "deterministic" | "externally_nondeterministic";
+        cwd_rel?: string | undefined;
+        exit_code?: number | undefined;
+        stdout_hash?: string | undefined;
+        stderr_hash?: string | undefined;
+        stdout_snippet?: string | undefined;
+        stderr_snippet?: string | undefined;
+    }[];
+    failures: string[];
+    trust_gap_reasons: ("worker_outcome_disagrees" | "head_identity_disagrees" | "patch_identity_disagrees" | "claimed_check_disagrees" | "authority_deviation")[];
+    verifier_id: string;
+    verifier_version: string;
+    started_at: string;
+    completed_at: string;
+    verified_head_sha?: string | undefined;
+    verified_patch_hash?: string | undefined;
+}>>;
+type AgentEngineVerification_v2 = z.infer<typeof AgentEngineVerification_v2>;
+declare function computeAgentEngineVerificationV2Hash(verification: AgentEngineVerification_v2): string;
+/** Validate the packet-declared check lane without conflating explicit engine extras. */
+declare function validateAgentEngineVerificationV2PacketReferences(packet: AgentTaskPacket_v1, verification: AgentEngineVerification_v2): {
+    valid: boolean;
+    errors: string[];
+};
+interface AgentTaskReceiptBindingContext {
+    packet: AgentTaskPacket_v1;
+    lease: WorkspaceLease_v1;
+    session: WorkerSession_v1;
+}
+interface AgentTaskReceiptV2BindingContext {
+    packet: AgentTaskPacket_v1;
+    lease: WorkspaceLease_v1;
+    session: WorkerSession_v1;
+    /** Runtime identity persisted with the exact WorkerSession attachment. */
+    workerRuntime: string;
+}
+/** Verify that a worker receipt belongs to one exact attempt and workspace. */
+declare function validateAgentTaskReceiptBinding(context: AgentTaskReceiptBindingContext, receipt: AgentTaskReceipt_v1): {
+    valid: boolean;
+    errors: string[];
+};
+/** Validate v2 claim identity only; this deliberately does not verify result truth. */
+declare function validateAgentTaskReceiptV2Binding(context: AgentTaskReceiptV2BindingContext, receipt: AgentTaskReceipt_v2): {
+    valid: boolean;
+    errors: string[];
+};
+declare const HumanActionPreconditions: z.ZodObject<{
+    run_revision: z.ZodNumber;
+    workspace_lease_revision: z.ZodNumber;
+    expected_head_sha: z.ZodString;
+}, z.core.$strict>;
+type HumanActionPreconditions = z.infer<typeof HumanActionPreconditions>;
+declare const HumanActionRequest_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    request_id: z.ZodString;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    worker_session_id: z.ZodString;
+    action: z.ZodEnum<{
+        other: "other";
+        approve_scope: "approve_scope";
+        sign_commit: "sign_commit";
+        authenticate: "authenticate";
+        approve_push: "approve_push";
+        approve_merge: "approve_merge";
+    }>;
+    summary: z.ZodString;
+    instructions: z.ZodArray<z.ZodString>;
+    suggested_commands: z.ZodArray<z.ZodString>;
+    preconditions: z.ZodObject<{
+        run_revision: z.ZodNumber;
+        workspace_lease_revision: z.ZodNumber;
+        expected_head_sha: z.ZodString;
+    }, z.core.$strict>;
+    requested_at: z.ZodString;
+    expires_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type HumanActionRequest_v1 = z.infer<typeof HumanActionRequest_v1>;
+declare const HumanActionReceipt_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    receipt_id: z.ZodString;
+    request_id: z.ZodString;
+    run_id: z.ZodString;
+    attempt_id: z.ZodString;
+    workspace_lease_id: z.ZodString;
+    worker_session_id: z.ZodString;
+    observed_preconditions: z.ZodObject<{
+        run_revision: z.ZodNumber;
+        workspace_lease_revision: z.ZodNumber;
+        expected_head_sha: z.ZodString;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        expired: "expired";
+        declined: "declined";
+    }>;
+    actor_id: z.ZodString;
+    summary: z.ZodString;
+    resulting_head_sha: z.ZodOptional<z.ZodString>;
+    completed_at: z.ZodString;
+}, z.core.$strict>;
+type HumanActionReceipt_v1 = z.infer<typeof HumanActionReceipt_v1>;
+/** Refuse stale or cross-attempt human approvals. */
+declare function validateHumanActionReceiptBinding(request: HumanActionRequest_v1, receipt: HumanActionReceipt_v1): {
+    valid: boolean;
+    errors: string[];
+};
+declare function parseWorkItem(data: unknown): WorkItem_v1;
+declare function parseRun(data: unknown): Run_v1;
+declare function parseAttempt(data: unknown): Attempt_v1;
+declare function parseAgentTaskPacket(data: unknown): AgentTaskPacket_v1;
+declare function parseExecutionEnvelope(data: unknown): ExecutionEnvelope_v1;
+declare function parseControllerLease(data: unknown): ControllerLease_v1;
+declare function parseWorkspaceLease(data: unknown): WorkspaceLease_v1;
+declare function parseWorkspaceAllocation(data: unknown): WorkspaceAllocation_v1;
+declare function parseWorkerSession(data: unknown): WorkerSession_v1;
+declare function parseAgentTaskReceipt(data: unknown): AgentTaskReceipt_v1;
+declare function parseAgentTaskReceiptV2(data: unknown): AgentTaskReceipt_v2;
+declare function parseAgentEngineVerification(data: unknown): AgentEngineVerification_v1;
+declare function parseAgentEngineVerificationV2(data: unknown): AgentEngineVerification_v2;
+declare function parseHumanActionRequest(data: unknown): HumanActionRequest_v1;
+declare function parseHumanActionReceipt(data: unknown): HumanActionReceipt_v1;
+
+declare const WorkspaceLifecycleLeaseStatus: z.ZodEnum<{
+    active: "active";
+    quarantined: "quarantined";
+    released: "released";
+    reserved: "reserved";
+    preserved: "preserved";
+    abandoned: "abandoned";
+}>;
+type WorkspaceLifecycleLeaseStatus = z.infer<typeof WorkspaceLifecycleLeaseStatus>;
+declare const ReleaseWorkspaceDisposition: z.ZodEnum<{
+    integrated: "integrated";
+    discarded: "discarded";
+}>;
+type ReleaseWorkspaceDisposition = z.infer<typeof ReleaseWorkspaceDisposition>;
+declare const WorkspaceReconciliationAction: z.ZodEnum<{
+    resume: "resume";
+    release: "release";
+    preserve: "preserve";
+    abandon: "abandon";
+}>;
+type WorkspaceReconciliationAction = z.infer<typeof WorkspaceReconciliationAction>;
+declare const WorkspaceLifecycleEventType: z.ZodEnum<{
+    attempt_created: "attempt_created";
+    attempt_transitioned: "attempt_transitioned";
+    workspace_acquired: "workspace_acquired";
+    workspace_heartbeat: "workspace_heartbeat";
+    workspace_released: "workspace_released";
+    workspace_reconciled: "workspace_reconciled";
+    workspace_quarantined: "workspace_quarantined";
+}>;
+type WorkspaceLifecycleEventType = z.infer<typeof WorkspaceLifecycleEventType>;
+declare const WorkerSessionEventType: z.ZodEnum<{
+    worker_session_attached: "worker_session_attached";
+    worker_session_heartbeat: "worker_session_heartbeat";
+    worker_session_ended: "worker_session_ended";
+}>;
+type WorkerSessionEventType = z.infer<typeof WorkerSessionEventType>;
+declare const AttemptReceiptDisposition: z.ZodEnum<{
+    verification_pending: "verification_pending";
+    retained_late: "retained_late";
+}>;
+type AttemptReceiptDisposition = z.infer<typeof AttemptReceiptDisposition>;
+declare const AttemptReceiptEventType: z.ZodEnum<{
+    attempt_receipt_submitted: "attempt_receipt_submitted";
+    attempt_receipt_retained_late: "attempt_receipt_retained_late";
+    attempt_receipt_replayed: "attempt_receipt_replayed";
+}>;
+type AttemptReceiptEventType = z.infer<typeof AttemptReceiptEventType>;
+declare const AttemptVerificationEventType: z.ZodEnum<{
+    attempt_verification_started: "attempt_verification_started";
+    attempt_verification_recorded: "attempt_verification_recorded";
+    attempt_verification_replayed: "attempt_verification_replayed";
+}>;
+type AttemptVerificationEventType = z.infer<typeof AttemptVerificationEventType>;
+declare const WorkspaceMutationFailureReason: z.ZodEnum<{
+    not_found: "not_found";
+    no_active_lease: "no_active_lease";
+    lease_mismatch: "lease_mismatch";
+    stale_fence: "stale_fence";
+    lease_expired: "lease_expired";
+    mutation_conflict: "mutation_conflict";
+    stale_run_revision: "stale_run_revision";
+    workspace_expired: "workspace_expired";
+    invalid_time: "invalid_time";
+    stale_attempt_revision: "stale_attempt_revision";
+    stale_workspace_revision: "stale_workspace_revision";
+    attempt_not_live: "attempt_not_live";
+    workspace_not_active: "workspace_not_active";
+    live_attempt_conflict: "live_attempt_conflict";
+    branch_conflict: "branch_conflict";
+    worktree_conflict: "worktree_conflict";
+    identity_mismatch: "identity_mismatch";
+    dirty_workspace: "dirty_workspace";
+    invalid_reconciliation: "invalid_reconciliation";
+    invalid_attempt_transition: "invalid_attempt_transition";
+    evidence_mismatch: "evidence_mismatch";
+    retry_delta_required: "retry_delta_required";
+    retry_delta_invalid: "retry_delta_invalid";
+    fanout_invalid: "fanout_invalid";
+}>;
+type WorkspaceMutationFailureReason = z.infer<typeof WorkspaceMutationFailureReason>;
+declare const WorkerSessionMutationFailureReason: z.ZodEnum<{
+    not_found: "not_found";
+    no_active_lease: "no_active_lease";
+    lease_mismatch: "lease_mismatch";
+    stale_fence: "stale_fence";
+    lease_expired: "lease_expired";
+    mutation_conflict: "mutation_conflict";
+    stale_run_revision: "stale_run_revision";
+    workspace_expired: "workspace_expired";
+    invalid_time: "invalid_time";
+    stale_attempt_revision: "stale_attempt_revision";
+    stale_workspace_revision: "stale_workspace_revision";
+    attempt_not_live: "attempt_not_live";
+    workspace_not_active: "workspace_not_active";
+    live_attempt_conflict: "live_attempt_conflict";
+    branch_conflict: "branch_conflict";
+    worktree_conflict: "worktree_conflict";
+    identity_mismatch: "identity_mismatch";
+    dirty_workspace: "dirty_workspace";
+    invalid_reconciliation: "invalid_reconciliation";
+    invalid_attempt_transition: "invalid_attempt_transition";
+    evidence_mismatch: "evidence_mismatch";
+    retry_delta_required: "retry_delta_required";
+    retry_delta_invalid: "retry_delta_invalid";
+    fanout_invalid: "fanout_invalid";
+    stale_session_revision: "stale_session_revision";
+    worker_session_not_active: "worker_session_not_active";
+    worker_session_conflict: "worker_session_conflict";
+}>;
+type WorkerSessionMutationFailureReason = z.infer<typeof WorkerSessionMutationFailureReason>;
+declare const AttemptReceiptFailureReason: z.ZodEnum<{
+    not_found: "not_found";
+    no_active_lease: "no_active_lease";
+    lease_mismatch: "lease_mismatch";
+    stale_fence: "stale_fence";
+    lease_expired: "lease_expired";
+    mutation_conflict: "mutation_conflict";
+    stale_run_revision: "stale_run_revision";
+    workspace_expired: "workspace_expired";
+    invalid_time: "invalid_time";
+    stale_attempt_revision: "stale_attempt_revision";
+    stale_workspace_revision: "stale_workspace_revision";
+    attempt_not_live: "attempt_not_live";
+    workspace_not_active: "workspace_not_active";
+    live_attempt_conflict: "live_attempt_conflict";
+    branch_conflict: "branch_conflict";
+    worktree_conflict: "worktree_conflict";
+    identity_mismatch: "identity_mismatch";
+    dirty_workspace: "dirty_workspace";
+    invalid_reconciliation: "invalid_reconciliation";
+    invalid_attempt_transition: "invalid_attempt_transition";
+    evidence_mismatch: "evidence_mismatch";
+    retry_delta_required: "retry_delta_required";
+    retry_delta_invalid: "retry_delta_invalid";
+    fanout_invalid: "fanout_invalid";
+    stale_session_revision: "stale_session_revision";
+    worker_session_not_active: "worker_session_not_active";
+    receipt_conflict: "receipt_conflict";
+}>;
+type AttemptReceiptFailureReason = z.infer<typeof AttemptReceiptFailureReason>;
+declare const AttemptVerificationFailureReason: z.ZodEnum<{
+    not_found: "not_found";
+    no_active_lease: "no_active_lease";
+    lease_mismatch: "lease_mismatch";
+    stale_fence: "stale_fence";
+    lease_expired: "lease_expired";
+    mutation_conflict: "mutation_conflict";
+    stale_run_revision: "stale_run_revision";
+    workspace_expired: "workspace_expired";
+    invalid_time: "invalid_time";
+    stale_attempt_revision: "stale_attempt_revision";
+    stale_workspace_revision: "stale_workspace_revision";
+    attempt_not_live: "attempt_not_live";
+    workspace_not_active: "workspace_not_active";
+    live_attempt_conflict: "live_attempt_conflict";
+    branch_conflict: "branch_conflict";
+    worktree_conflict: "worktree_conflict";
+    identity_mismatch: "identity_mismatch";
+    dirty_workspace: "dirty_workspace";
+    invalid_reconciliation: "invalid_reconciliation";
+    invalid_attempt_transition: "invalid_attempt_transition";
+    evidence_mismatch: "evidence_mismatch";
+    retry_delta_required: "retry_delta_required";
+    retry_delta_invalid: "retry_delta_invalid";
+    fanout_invalid: "fanout_invalid";
+    stale_session_revision: "stale_session_revision";
+    verification_conflict: "verification_conflict";
+}>;
+type AttemptVerificationFailureReason = z.infer<typeof AttemptVerificationFailureReason>;
+declare const WorkspaceObservation: z.ZodObject<{
+    exists: z.ZodBoolean;
+    registered: z.ZodBoolean;
+    repositoryId: z.ZodNullable<z.ZodString>;
+    hostId: z.ZodString;
+    gitRuntime: z.ZodString;
+    projectRoot: z.ZodNullable<z.ZodString>;
+    branch: z.ZodNullable<z.ZodString>;
+    worktreePath: z.ZodString;
+    attemptId: z.ZodNullable<z.ZodString>;
+    headSha: z.ZodNullable<z.ZodString>;
+    cleanliness: z.ZodEnum<{
+        clean: "clean";
+        dirty: "dirty";
+    }>;
+    dirtyPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type WorkspaceObservation = z.infer<typeof WorkspaceObservation>;
+
+/** Durable attempt state. Attempts exist before a workspace is allocated. */
+interface AttemptRecord {
+    attemptId: string;
+    runId: string;
+    runRevision: number;
+    workItemId: string;
+    workItemRevision: number;
+    packetId: string;
+    packetHash: string;
+    baseSha: string;
+    revision: number;
+    status: AttemptStatus;
+    workspaceLeaseId: string | null;
+    receiptId: string | null;
+    verificationId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+}
+/** Canonical immutable retry delta persisted atomically with its new Attempt. */
+interface AttemptRetryDeltaRecord {
+    attemptId: string;
+    previousAttemptId: string;
+    deltaHash: string;
+    deltaJson: string;
+    createdAt: string;
+}
+/** Canonical immutable declaration for one bounded parallel comparison. */
+interface FanoutPlanRecord {
+    fanoutId: string;
+    runId: string;
+    workItemId: string;
+    workItemRevision: number;
+    planHash: string;
+    planJson: string;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    createdAt: string;
+}
+/** Exact declared premise occupied by an Attempt. */
+interface FanoutAttemptBindingRecord {
+    fanoutId: string;
+    attemptId: string;
+    premiseId: string;
+    premiseHash: string;
+    planHash: string;
+    createdAt: string;
+}
+/** Immutable engine-owned fan-in comparison. */
+interface FanInDecisionRecord {
+    decisionId: string;
+    fanoutId: string;
+    runId: string;
+    workItemId: string;
+    workItemRevision: number;
+    decisionHash: string;
+    decisionJson: string;
+    selectedAttemptId: string | null;
+    outcome: AgentWorkFanInDecision_v1["decision"];
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    createdAt: string;
+}
+interface WorkspaceIdentity {
+    repositoryId: string;
+    hostId: string;
+    gitRuntime: string;
+    projectRoot: string;
+    branch: string;
+    worktreePath: string;
+    attemptId: string;
+}
+/**
+ * Controller-local persistence for workspace ownership and reconciliation.
+ * This is deliberately distinct from the portable `WorkspaceLease_v1`
+ * protocol contract: the broker later combines this machine-local state with
+ * the immutable scope and authority from the task packet.
+ */
+interface WorkspaceLifecycleLeaseRecord extends WorkspaceIdentity {
+    leaseId: string;
+    runId: string;
+    runRevision: number;
+    workItemId: string;
+    workItemRevision: number;
+    packetId: string;
+    packetHash: string;
+    revision: number;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    baseSha: string;
+    status: WorkspaceLifecycleLeaseStatus;
+    acquiredAt: string;
+    heartbeatAt: string;
+    expiresAt: string;
+    releasedAt?: string;
+    cleanupDisposition?: WorkspaceCleanupDisposition;
+    lastObservation?: WorkspaceObservation;
+}
+interface WorkspaceLifecycleEvent {
+    runId: string;
+    attemptId: string;
+    mutationId: string;
+    sequence: number;
+    attemptRevision: number;
+    workspaceLeaseRevision: number | null;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    type: WorkspaceLifecycleEventType;
+    payload: JsonValue;
+    createdAt: string;
+}
+/** Durable identity and observed lifecycle for one native worker attached to an Attempt. */
+interface WorkerSessionRecord {
+    sessionId: string;
+    revision: number;
+    runId: string;
+    attemptId: string;
+    packetId: string;
+    packetHash: string;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    executionEnvelopeId: string;
+    executionEnvelopeHash: string;
+    hostId: string;
+    workerRuntime: string;
+    gitRuntime: string;
+    backend: WorkerSessionBackend;
+    workerId: string;
+    model?: string;
+    status: WorkerSessionStatus;
+    startedAt: string;
+    heartbeatAt: string;
+    endedAt?: string;
+    exitReason?: string;
+    exitCode?: number;
+    exitSummary?: string;
+}
+/** Immutable adapter/enforcement identity negotiated before a worker session is attached. */
+interface WorkerAdapterBindingRecord {
+    sessionId: string;
+    adapterId: string;
+    adapterVersion: string;
+    enforcementSummaryHash: string;
+    trustGapDimensions: string[];
+    createdAt: string;
+}
+interface WorkerSessionEvent {
+    runId: string;
+    attemptId: string;
+    sessionId: string;
+    mutationId: string;
+    sequence: number;
+    attemptRevision: number;
+    workspaceLeaseRevision: number;
+    sessionRevision: number;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    type: WorkerSessionEventType;
+    payload: JsonValue;
+    createdAt: string;
+}
+interface AuthenticatedMutationInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+}
+interface AttemptReceiptRecord {
+    receiptId: string;
+    receiptHash: string;
+    receiptJson: string;
+    runId: string;
+    workItemId: string;
+    workItemRevision: number;
+    attemptId: string;
+    packetId: string;
+    packetHash: string;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    workerSessionId: string;
+    workerSessionRevision: number;
+    workerRuntime: string;
+    observedBaseSha: string;
+    finalHeadSha?: string;
+    patchHash?: string;
+    outcome: AgentTaskReceiptOutcome;
+    disposition: AttemptReceiptDisposition;
+    submittedAt: string;
+    recordedAt: string;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    resultingAttemptRevision: number;
+    resultingAttemptStatus: AttemptStatus;
+}
+interface AttemptReceiptEvent {
+    runId: string;
+    attemptId: string;
+    receiptId: string;
+    receiptHash: string;
+    mutationId: string;
+    sequence: number;
+    attemptRevision: number;
+    workspaceLeaseRevision: number;
+    workerSessionRevision: number;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    type: AttemptReceiptEventType;
+    disposition: AttemptReceiptDisposition;
+    outcome: AgentTaskReceiptOutcome;
+    createdAt: string;
+}
+interface SubmitAttemptReceiptInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+    attemptId: string;
+    expectedAttemptRevision: number;
+    workspaceLeaseId: string;
+    expectedWorkspaceLeaseRevision: number;
+    workerSessionId: string;
+    expectedWorkerSessionRevision: number;
+    receipt: AgentTaskReceipt_v2;
+}
+type AttemptReceiptSubmissionResult = {
+    submitted: true;
+    receipt: AttemptReceiptRecord;
+    attempt: AttemptRecord;
+    event: AttemptReceiptEvent;
+    idempotentReplay: boolean;
+} | {
+    submitted: false;
+    reason: AttemptReceiptFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
+interface AttemptVerificationRecord {
+    verificationId: string;
+    verificationHash: string;
+    verificationJson: string;
+    runId: string;
+    workItemId: string;
+    workItemRevision: number;
+    attemptId: string;
+    packetId: string;
+    packetHash: string;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    workerSessionId: string;
+    workerSessionRevision: number;
+    receiptId: string;
+    receiptHash: string;
+    observedBaseSha: string;
+    verifiedHeadSha?: string;
+    verifiedPatchHash?: string;
+    workspaceObservationHash: string;
+    outcome: VerificationOutcome;
+    trustGapReasons: EngineVerificationTrustGapReason_v2[];
+    verifierId: string;
+    verifierVersion: string;
+    startedAt: string;
+    completedAt: string;
+    recordedAt: string;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    resultingAttemptRevision: number;
+    resultingAttemptStatus: AttemptStatus;
+}
+interface AttemptVerificationAuthorizationRecord {
+    verificationId: string;
+    runId: string;
+    attemptId: string;
+    attemptRevision: number;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    workerSessionId: string;
+    workerSessionRevision: number;
+    receiptId: string;
+    receiptHash: string;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    startedAt: string;
+}
+interface AttemptVerificationEvent {
+    runId: string;
+    attemptId: string;
+    verificationId: string;
+    verificationHash: string | null;
+    receiptId: string;
+    receiptHash: string;
+    mutationId: string;
+    sequence: number;
+    attemptRevision: number;
+    workspaceLeaseRevision: number;
+    workerSessionRevision: number;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    type: AttemptVerificationEventType;
+    outcome: VerificationOutcome | null;
+    resultingAttemptStatus: AttemptStatus;
+    createdAt: string;
+}
+interface SubmitAttemptVerificationInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+    attemptId: string;
+    expectedAttemptRevision: number;
+    workspaceLeaseId: string;
+    expectedWorkspaceLeaseRevision: number;
+    workerSessionId: string;
+    expectedWorkerSessionRevision: number;
+    receiptId: string;
+    receiptHash: string;
+    verification: AgentEngineVerification_v2;
+}
+/** Built-in fail-closed policy used by the first public acceptance surface. */
+declare const STRICT_ATTEMPT_ACCEPTANCE_POLICY_ID: "lexrunner.strict-pass";
+declare const STRICT_ATTEMPT_ACCEPTANCE_POLICY_VERSION: "1.0.0";
+interface BeginAttemptVerificationInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+    verificationId: string;
+    attemptId: string;
+    expectedAttemptRevision: number;
+    workspaceLeaseId: string;
+    expectedWorkspaceLeaseRevision: number;
+    workerSessionId: string;
+    expectedWorkerSessionRevision: number;
+    receiptId: string;
+    receiptHash: string;
+}
+type AttemptVerificationBeginResult = {
+    started: true;
+    authorization: AttemptVerificationAuthorizationRecord;
+    attempt: AttemptRecord;
+    event: AttemptVerificationEvent;
+    idempotentReplay: boolean;
+} | {
+    started: false;
+    reason: AttemptVerificationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
+type AttemptVerificationSubmissionResult = {
+    recorded: true;
+    verification: AttemptVerificationRecord;
+    attempt: AttemptRecord;
+    event: AttemptVerificationEvent;
+    idempotentReplay: boolean;
+} | {
+    recorded: false;
+    reason: AttemptVerificationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
+type WorkerSessionMutationResult = {
+    updated: true;
+    attempt: AttemptRecord;
+    workerSession: WorkerSessionRecord;
+    event: WorkerSessionEvent;
+    idempotentReplay: boolean;
+} | {
+    updated: false;
+    reason: WorkerSessionMutationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
+interface CreateAttemptInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workItemId: string;
+    workItemRevision: number;
+    packetId: string;
+    packetHash: string;
+    baseSha: string;
+    retry?: AttemptRetryDelta_v1;
+    fanout?: FanoutAttemptBinding_v1;
+}
+interface CreateFanoutPlanInput extends AuthenticatedMutationInput {
+    plan: AgentWorkFanoutPlan_v1;
+}
+interface CommitFanInDecisionInput extends AuthenticatedMutationInput {
+    decision: AgentWorkFanInDecision_v1;
+}
+type FanoutPlanMutationResult = {
+    created: true;
+    plan: FanoutPlanRecord;
+    idempotentReplay: boolean;
+} | {
+    created: false;
+    reason: WorkspaceMutationFailureReason | "fanout_conflict" | "fanout_not_found" | "fanout_evidence_mismatch";
+    currentRunRevision?: number;
+};
+type FanInDecisionMutationResult = {
+    recorded: true;
+    decision: FanInDecisionRecord;
+    idempotentReplay: boolean;
+} | {
+    recorded: false;
+    reason: WorkspaceMutationFailureReason | "fanout_conflict" | "fanout_not_found" | "fanout_incomplete" | "fanout_evidence_mismatch";
+    currentRunRevision?: number;
+};
+interface AcquireWorkspaceInput extends AuthenticatedMutationInput, WorkspaceIdentity {
+    workspaceLeaseId: string;
+    workItemId: string;
+    baseSha: string;
+    expectedAttemptRevision: number;
+    ttlMs: number;
+    observation?: WorkspaceObservation;
+}
+interface TransitionAttemptInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    expectedAttemptRevision: number;
+    status: AttemptStatus;
+    receiptId?: string;
+    verificationId?: string;
+    details?: JsonValue;
+}
+interface HeartbeatWorkspaceInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+    ttlMs: number;
+    observation: WorkspaceObservation;
+}
+interface ReleaseWorkspaceInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+    disposition: ReleaseWorkspaceDisposition;
+    observation: WorkspaceObservation;
+}
+interface ReconcileWorkspaceInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+    action: WorkspaceReconciliationAction;
+    ttlMs?: number;
+    observation: WorkspaceObservation;
+}
+interface QuarantineWorkspaceInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+    reason: string;
+    observation: WorkspaceObservation;
+}
+type WorkspaceMutationResult = {
+    updated: true;
+    attempt: AttemptRecord;
+    workspaceLease: WorkspaceLifecycleLeaseRecord | null;
+    event: WorkspaceLifecycleEvent;
+    idempotentReplay: boolean;
+} | {
+    updated: false;
+    reason: WorkspaceMutationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentRunRevision?: number;
+};
+interface WorkspaceLifecycleStore {
+    createAttempt(input: CreateAttemptInput): Promise<WorkspaceMutationResult>;
+    transitionAttempt(input: TransitionAttemptInput): Promise<WorkspaceMutationResult>;
+    acquireWorkspace(input: AcquireWorkspaceInput): Promise<WorkspaceMutationResult>;
+    heartbeatWorkspace(input: HeartbeatWorkspaceInput): Promise<WorkspaceMutationResult>;
+    releaseWorkspace(input: ReleaseWorkspaceInput): Promise<WorkspaceMutationResult>;
+    reconcileWorkspace(input: ReconcileWorkspaceInput): Promise<WorkspaceMutationResult>;
+    quarantineWorkspace(input: QuarantineWorkspaceInput): Promise<WorkspaceMutationResult>;
+    getAttempt(attemptId: string): Promise<AttemptRecord | null>;
+    listAttempts(runId: string): Promise<AttemptRecord[]>;
+    getAttemptRetryDelta(attemptId: string): Promise<AttemptRetryDeltaRecord | null>;
+    getWorkspaceLease(leaseId: string): Promise<WorkspaceLifecycleLeaseRecord | null>;
+    listWorkspaceLeases(runId: string): Promise<WorkspaceLifecycleLeaseRecord[]>;
+    listWorkspaceLifecycleEvents(runId: string): Promise<WorkspaceLifecycleEvent[]>;
+}
+/** Durable planning and comparison port for one-level bounded parallel Attempts. */
+interface AgentWorkFanoutStore {
+    createFanoutPlan(input: CreateFanoutPlanInput): Promise<FanoutPlanMutationResult>;
+    getFanoutPlan(fanoutId: string): Promise<FanoutPlanRecord | null>;
+    getAttemptFanoutBinding(attemptId: string): Promise<FanoutAttemptBindingRecord | null>;
+    listFanoutAttemptBindings(fanoutId: string): Promise<FanoutAttemptBindingRecord[]>;
+    commitFanInDecision(input: CommitFanInDecisionInput): Promise<FanInDecisionMutationResult>;
+    getFanInDecision(decisionId: string): Promise<FanInDecisionRecord | null>;
+    getFanInDecisionForFanout(fanoutId: string): Promise<FanInDecisionRecord | null>;
+}
+/** Additive immutable AgentTaskReceipt v2 persistence port. */
+interface AttemptReceiptStore {
+    submitAttemptReceipt(input: SubmitAttemptReceiptInput): Promise<AttemptReceiptSubmissionResult>;
+    getAttemptReceipt(receiptId: string): Promise<AttemptReceiptRecord | null>;
+    getAttemptReceiptForAttempt(attemptId: string): Promise<AttemptReceiptRecord | null>;
+    getAttemptReceiptByHash(receiptHash: string): Promise<AttemptReceiptRecord | null>;
+    listAttemptReceiptEvents(runId: string): Promise<AttemptReceiptEvent[]>;
+}
+/** Additive immutable AgentEngineVerification v2 persistence port. */
+interface AttemptVerificationStore {
+    beginAttemptVerification(input: BeginAttemptVerificationInput): Promise<AttemptVerificationBeginResult>;
+    submitAttemptVerification(input: SubmitAttemptVerificationInput): Promise<AttemptVerificationSubmissionResult>;
+    getAttemptVerification(verificationId: string): Promise<AttemptVerificationRecord | null>;
+    getAttemptVerificationForAttempt(attemptId: string): Promise<AttemptVerificationRecord | null>;
+    getAttemptVerificationByHash(verificationHash: string): Promise<AttemptVerificationRecord | null>;
+    getAttemptVerificationAuthorization(verificationId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    getAttemptVerificationAuthorizationForAttempt(attemptId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    listAttemptVerificationEvents(runId: string): Promise<AttemptVerificationEvent[]>;
+}
+
+type LifecyclePhase = "controller" | "attempt_create" | "workspace_allocate" | "workspace_resume" | "launch_authorize";
+type LifecycleFailureReason = "controller_held" | "store_rejected" | "workspace_rejected" | "identity_mismatch" | "inactive_workspace" | "stale_authority" | "expired_workspace" | "reconciliation_required";
+interface AgentWorkLifecycleSuccess {
+    ok: true;
+    outcome: "launch_authorized";
+    controllerLease: ControllerLease;
+    run: BoundedRunStatus;
+    attempt: BoundedAttemptStatus;
+    workspace: BoundedWorkspaceStatus;
+    idempotentReplay: boolean;
+}
+interface AgentWorkLifecycleFailure {
+    ok: false;
+    phase: LifecyclePhase;
+    reason: LifecycleFailureReason;
+    reconciliationRequired: boolean;
+    status?: AgentWorkStatus;
+    storeReason?: WorkspaceMutationFailureReason;
+}
+type AgentWorkLifecycleResult = AgentWorkLifecycleSuccess | AgentWorkLifecycleFailure;
+interface BoundedRunStatus {
+    runId: string;
+    revision: number;
+    state: string | null;
+    updatedAt: string | null;
+    controller: {
+        controllerId: string;
+        leaseId: string;
+        fencingToken: number;
+        expiresAt: string;
+    } | null;
+}
+interface BoundedAttemptStatus {
+    attemptId: string;
+    revision: number;
+    status: AttemptRecord["status"];
+    workItemId: string;
+    workItemRevision: number;
+    packetId: string;
+    packetHash: string;
+    baseSha: string;
+    workspaceLeaseId: string | null;
+    updatedAt: string;
+    completedAt: string | null;
+}
+interface BoundedWorkspaceStatus {
+    leaseId: string;
+    revision: number;
+    status: WorkspaceLifecycleLeaseRecord["status"];
+    repositoryId: string;
+    hostId: string;
+    gitRuntime: string;
+    branch: string;
+    worktreePath: string;
+    baseSha: string;
+    heartbeatAt: string;
+    expiresAt: string;
+    cleanupDisposition: WorkspaceLifecycleLeaseRecord["cleanupDisposition"] | null;
+    observation: {
+        exists: boolean;
+        registered: boolean;
+        headSha: string | null;
+        cleanliness: WorkspaceObservation["cleanliness"];
+        dirtyPathCount: number;
+        reason: string | null;
+    } | null;
+}
+interface AgentWorkStatus {
+    run: BoundedRunStatus | null;
+    attempt: BoundedAttemptStatus | null;
+    workspace: BoundedWorkspaceStatus | null;
+    launch: BoundedLaunchStatus | null;
+}
+interface BoundedLaunchStatus {
+    state: "not_authorized" | "binding_missing" | "binding_stale" | "bound" | "failed_closed" | "inconsistent";
+    reconciliationRequired: boolean;
+}
+
+interface WorkerSessionStatusResult {
+    workerSession: WorkerSessionRecord | null;
+    adapter: BoundedWorkerAdapterStatus | null;
+}
+interface BoundedWorkerAdapterStatus extends WorkerAdapterBindingRecord {
+    enforcement: "enforced" | "trust_gap";
+}
+
+interface AttemptLaunchBundleSuccess {
+    ok: true;
+    outcome: "launch_bundle_ready";
+    lifecycle: AgentWorkLifecycleSuccess;
+    packet: AgentTaskPacket_v1;
+    envelope: ExecutionEnvelope_v1;
+}
+type AttemptLaunchBundleResult = AttemptLaunchBundleSuccess | AgentWorkLifecycleFailure;
+
+declare const AttemptStartRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    runtime: z.ZodObject<{
+        databasePath: z.ZodString;
+        repositoryId: z.ZodString;
+        repositoryRoot: z.ZodString;
+        worktreeRoot: z.ZodString;
+        hostId: z.ZodString;
+        gitRuntime: z.ZodString;
+        pathComparison: z.ZodEnum<{
+            "case-sensitive": "case-sensitive";
+            "case-insensitive": "case-insensitive";
+        }>;
+        gitExecutable: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxDirtyPaths: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    attempt: z.ZodObject<{
+        runId: z.ZodString;
+        initialRunState: z.ZodObject<{
+            runId: z.ZodString;
+            mode: z.ZodString;
+            procedure: z.ZodString;
+            repo: z.ZodString;
+            task: z.ZodOptional<z.ZodString>;
+            state: z.ZodString;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            completedAt: z.ZodOptional<z.ZodString>;
+            completedSteps: z.ZodArray<z.ZodString>;
+            currentStep: z.ZodNullable<z.ZodString>;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            persona: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodString;
+                forbidden: z.ZodArray<z.ZodString>;
+                completionGates: z.ZodArray<z.ZodString>;
+                decisionStyle: z.ZodOptional<z.ZodObject<{
+                    preferSmallDiffs: z.ZodOptional<z.ZodBoolean>;
+                    requireRationaleForSkips: z.ZodOptional<z.ZodBoolean>;
+                    escalateSecurityFindings: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                outputFormat: z.ZodOptional<z.ZodObject<{
+                    severityLevels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    requireSeverityOnFindings: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        controller: z.ZodObject<{
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            now: z.ZodString;
+            ttlMs: z.ZodNumber;
+        }, z.core.$strict>;
+        attempt: z.ZodObject<{
+            attemptId: z.ZodString;
+            workItemId: z.ZodString;
+            workItemRevision: z.ZodNumber;
+            packetId: z.ZodString;
+            packetHash: z.ZodString;
+            baseSha: z.ZodString;
+        }, z.core.$strict>;
+        workspace: z.ZodObject<{
+            workspaceLeaseId: z.ZodString;
+            repositoryId: z.ZodString;
+            hostId: z.ZodString;
+            gitRuntime: z.ZodString;
+            projectRoot: z.ZodString;
+            branch: z.ZodString;
+            worktreePath: z.ZodString;
+            ttlMs: z.ZodNumber;
+        }, z.core.$strict>;
+        mutations: z.ZodObject<{
+            createAttempt: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            reserveWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            activateWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            resumeWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            quarantineWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            authorizeLaunch: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        broker: z.ZodOptional<z.ZodObject<{
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptPrepareRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    runtime: z.ZodObject<{
+        databasePath: z.ZodString;
+        repositoryId: z.ZodString;
+        repositoryRoot: z.ZodString;
+        worktreeRoot: z.ZodString;
+        hostId: z.ZodString;
+        gitRuntime: z.ZodString;
+        pathComparison: z.ZodEnum<{
+            "case-sensitive": "case-sensitive";
+            "case-insensitive": "case-insensitive";
+        }>;
+        gitExecutable: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxDirtyPaths: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    workItem: z.ZodObject<{
+        schema_version: z.ZodLiteral<"1.0.0">;
+        work_item_id: z.ZodString;
+        revision: z.ZodNumber;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                manual: "manual";
+                github: "github";
+                jira: "jira";
+            }>;
+            external_id: z.ZodString;
+            revision: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+            captured_at: z.ZodString;
+        }, z.core.$strict>;
+        repository: z.ZodObject<{
+            id: z.ZodString;
+            remote_url: z.ZodOptional<z.ZodString>;
+            default_branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        title: z.ZodString;
+        objective: z.ZodString;
+        description: z.ZodString;
+        acceptance_criteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+        constraints: z.ZodArray<z.ZodString>;
+        labels: z.ZodArray<z.ZodString>;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    identity: z.ZodObject<{
+        runId: z.ZodString;
+        attemptId: z.ZodString;
+        baseSha: z.ZodString;
+    }, z.core.$strict>;
+    packet: z.ZodObject<{
+        scope: z.ZodObject<{
+            read_globs: z.ZodArray<z.ZodString>;
+            write_globs: z.ZodArray<z.ZodString>;
+            deny_globs: z.ZodArray<z.ZodString>;
+            cross_repo_allowed: z.ZodBoolean;
+        }, z.core.$strict>;
+        budget: z.ZodObject<{
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+            max_tool_calls: z.ZodOptional<z.ZodNumber>;
+            max_elapsed_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        verification: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            argv: z.ZodArray<z.ZodString>;
+            cwd_rel: z.ZodOptional<z.ZodString>;
+            depends_on: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            expected_exit_codes: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>>;
+        authority: z.ZodObject<{
+            edit: z.ZodBoolean;
+            git_write: z.ZodBoolean;
+            github_write: z.ZodBoolean;
+            external_runtime: z.ZodBoolean;
+            secrets: z.ZodBoolean;
+            signing: z.ZodBoolean;
+            release: z.ZodBoolean;
+        }, z.core.$strict>;
+        instructions: z.ZodArray<z.ZodString>;
+        packetId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strict>;
+    envelope: z.ZodObject<{
+        envelopeId: z.ZodString;
+        os: z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+            other: "other";
+            windows: "windows";
+        }>;
+        architecture: z.ZodString;
+        workerRuntime: z.ZodString;
+        projectRoot: z.ZodString;
+        executionRoot: z.ZodString;
+        exposedEnvironmentKeys: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>;
+    attempt: z.ZodObject<{
+        controller: z.ZodObject<{
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            now: z.ZodString;
+            ttlMs: z.ZodNumber;
+        }, z.core.$strict>;
+        broker: z.ZodOptional<z.ZodObject<{
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        initialRunState: z.ZodObject<{
+            runId: z.ZodString;
+            mode: z.ZodString;
+            procedure: z.ZodString;
+            repo: z.ZodString;
+            task: z.ZodOptional<z.ZodString>;
+            state: z.ZodString;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            completedAt: z.ZodOptional<z.ZodString>;
+            completedSteps: z.ZodArray<z.ZodString>;
+            currentStep: z.ZodNullable<z.ZodString>;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            persona: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodString;
+                forbidden: z.ZodArray<z.ZodString>;
+                completionGates: z.ZodArray<z.ZodString>;
+                decisionStyle: z.ZodOptional<z.ZodObject<{
+                    preferSmallDiffs: z.ZodOptional<z.ZodBoolean>;
+                    requireRationaleForSkips: z.ZodOptional<z.ZodBoolean>;
+                    escalateSecurityFindings: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                outputFormat: z.ZodOptional<z.ZodObject<{
+                    severityLevels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    requireSeverityOnFindings: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        mutations: z.ZodObject<{
+            createAttempt: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            reserveWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            activateWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            resumeWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            quarantineWorkspace: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+            authorizeLaunch: z.ZodObject<{
+                mutationId: z.ZodString;
+                now: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        workspace: z.ZodObject<{
+            branch: z.ZodString;
+            worktreePath: z.ZodString;
+            ttlMs: z.ZodNumber;
+            workspaceLeaseId: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptStatusInputJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strict>>;
+interface AdapterInputError {
+    code: "invalid_input";
+    message: string;
+    issues: Array<{
+        path: string;
+        message: string;
+    }>;
+}
+interface AdapterOperationError {
+    code: "operation_failed";
+    message: string;
+}
+type AdapterError = AdapterInputError | AdapterOperationError;
+type AgentWorkHandlerResult<T> = {
+    ok: true;
+    result: T;
+} | {
+    ok: false;
+    error: AdapterError;
+};
+interface AttemptLifecycleHandlers {
+    start(request: unknown): Promise<AgentWorkHandlerResult<AgentWorkLifecycleResult>>;
+    status(request: unknown): Promise<AgentWorkHandlerResult<AgentWorkStatus>>;
+}
+interface AttemptPreparationHandler {
+    prepare(request: unknown): Promise<AgentWorkHandlerResult<AttemptLaunchBundleResult>>;
+}
+/** Top-level lifecycle seam. Every request owns and closes its SQLite connection. */
+declare function createAttemptLifecycleHandlers(): AttemptLifecycleHandlers & AttemptPreparationHandler;
+
+declare const AttemptWorkerAttachRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    runtime: z.ZodObject<{
+        databasePath: z.ZodString;
+        repositoryId: z.ZodString;
+        repositoryRoot: z.ZodString;
+        worktreeRoot: z.ZodString;
+        hostId: z.ZodString;
+        gitRuntime: z.ZodString;
+        pathComparison: z.ZodEnum<{
+            "case-sensitive": "case-sensitive";
+            "case-insensitive": "case-insensitive";
+        }>;
+        gitExecutable: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxDirtyPaths: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    attach: z.ZodObject<{
+        envelope: z.ZodObject<{
+            schema_version: z.ZodLiteral<"1.0.0">;
+            envelope_id: z.ZodString;
+            run_id: z.ZodString;
+            attempt_id: z.ZodString;
+            packet_id: z.ZodString;
+            packet_hash: z.ZodString;
+            workspace_lease_id: z.ZodString;
+            workspace_lease_revision: z.ZodNumber;
+            expected_head_sha: z.ZodString;
+            branch: z.ZodString;
+            runtime: z.ZodObject<{
+                host_id: z.ZodString;
+                os: z.ZodEnum<{
+                    darwin: "darwin";
+                    linux: "linux";
+                    other: "other";
+                    windows: "windows";
+                }>;
+                architecture: z.ZodString;
+                worker_runtime: z.ZodString;
+                git_runtime: z.ZodString;
+            }, z.core.$strict>;
+            paths: z.ZodObject<{
+                project_root: z.ZodString;
+                execution_root: z.ZodString;
+                worktree_root: z.ZodString;
+            }, z.core.$strict>;
+            path_mappings: z.ZodArray<z.ZodObject<{
+                runtime: z.ZodString;
+                worktree_root: z.ZodString;
+            }, z.core.$strict>>;
+            exposed_environment_keys: z.ZodArray<z.ZodString>;
+            created_at: z.ZodString;
+        }, z.core.$strict>;
+        worker: z.ZodObject<{
+            backend: z.ZodEnum<{
+                external: "external";
+                "host-subagent": "host-subagent";
+                "codex-cli": "codex-cli";
+            }>;
+            workerId: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            startedAt: z.ZodString;
+        }, z.core.$strict>;
+        adapter: z.ZodObject<{
+            schema_version: z.ZodLiteral<"1.0.0">;
+            adapter_id: z.ZodString;
+            adapter_version: z.ZodString;
+            mode: z.ZodEnum<{
+                launch: "launch";
+                assisted_attach: "assisted_attach";
+            }>;
+            accepted_trust_gaps: z.ZodArray<z.ZodEnum<{
+                network: "network";
+                release: "release";
+                git_write: "git_write";
+                github_write: "github_write";
+                external_runtime: "external_runtime";
+                secrets: "secrets";
+                signing: "signing";
+                filesystem_read: "filesystem_read";
+                filesystem_write: "filesystem_write";
+                nested_delegation: "nested_delegation";
+            }>>;
+        }, z.core.$strict>;
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        mutation: z.ZodObject<{
+            mutationId: z.ZodString;
+            now: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptWorkerHeartbeatRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    heartbeat: z.ZodObject<{
+        expectedWorkerSessionRevision: z.ZodNumber;
+        status: z.ZodOptional<z.ZodEnum<{
+            awaiting_human: "awaiting_human";
+            running: "running";
+        }>>;
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        mutation: z.ZodObject<{
+            mutationId: z.ZodString;
+            now: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptWorkerEndRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    end: z.ZodObject<{
+        expectedWorkerSessionRevision: z.ZodNumber;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            lost: "lost";
+        }>;
+        exit: z.ZodObject<{
+            code: z.ZodOptional<z.ZodNumber>;
+            signal: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        mutation: z.ZodObject<{
+            mutationId: z.ZodString;
+            now: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptWorkerStatusRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strict>>;
+interface AttemptWorkerHandlers {
+    attach(request: unknown): Promise<AgentWorkHandlerResult<WorkerSessionMutationResult>>;
+    heartbeat(request: unknown): Promise<AgentWorkHandlerResult<WorkerSessionMutationResult>>;
+    end(request: unknown): Promise<AgentWorkHandlerResult<WorkerSessionMutationResult>>;
+    status(request: unknown): Promise<AgentWorkHandlerResult<WorkerSessionStatusResult>>;
+}
+declare function createAttemptWorkerHandlers(): AttemptWorkerHandlers;
+
+interface VerificationWorkspaceObservation {
+    headSha: string;
+    patchHash: string;
+    observationHash: string;
+}
+type VerificationCommandFailureKind = "nonzero_exit" | "spawn_error" | "timeout" | "cancelled" | "output_limit";
+interface VerificationCommandResult {
+    ok: boolean;
+    failureKind?: VerificationCommandFailureKind;
+    exitCode?: number;
+    stdoutHash?: string;
+    stderrHash?: string;
+    stdoutSnippet?: string;
+    stderrSnippet?: string;
+    durationMs: number;
+}
+interface AttemptVerificationRuntime {
+    resolveEnvironment(keys: readonly string[]): Readonly<Record<string, string>>;
+    observe(input: {
+        lease: WorkspaceLifecycleLeaseRecord;
+        receipt: AgentTaskReceipt_v2;
+    }): Promise<VerificationWorkspaceObservation>;
+    runCheck(input: {
+        argv: readonly string[];
+        cwd: string;
+        environment: Readonly<Record<string, string>>;
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }): Promise<VerificationCommandResult>;
+    resolveCheckCwd(worktreePath: string, cwdRel?: string): Promise<string>;
+}
+
+type AttemptVerificationRunResult = {
+    recorded: true;
+    verificationId: string;
+    verificationHash: string;
+    attemptId: string;
+    outcome: VerificationOutcome;
+    attemptRevision: number;
+    attemptStatus: AttemptRecord["status"];
+    trustGapCount: number;
+    checkCounts: Record<VerificationOutcome, number>;
+    idempotentReplay: boolean;
+} | {
+    recorded: false;
+    reason: AttemptVerificationFailureReason;
+    message?: string;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
+interface AttemptVerificationStatusResult {
+    verification: null | {
+        verificationId: string;
+        verificationHash: string;
+        attemptId: string;
+        outcome: VerificationOutcome;
+        resultingAttemptRevision: number;
+        resultingAttemptStatus: AttemptRecord["status"];
+        resultIdentity: {
+            headSha?: string;
+            patchHash?: string;
+        };
+        trustGapCount: number;
+        checkCounts: Record<VerificationOutcome, number>;
+        recordedAt: string;
+        diagnostics?: {
+            summary: string;
+            failures: string[];
+            trustGapReasons: EngineVerificationTrustGapReason_v2[];
+            checks: AgentEngineVerification_v2["checks"];
+        };
+    };
+}
+type AttemptAcceptanceResult = {
+    applied: true;
+    attemptId: string;
+    decision: "accepted" | "rejected";
+    attemptRevision: number;
+    policyId: typeof STRICT_ATTEMPT_ACCEPTANCE_POLICY_ID;
+    policyVersion: typeof STRICT_ATTEMPT_ACCEPTANCE_POLICY_VERSION;
+    reasonCodes: string[];
+    idempotentReplay: boolean;
+} | {
+    applied: false;
+    reason: WorkspaceMutationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentRunRevision?: number;
+};
+interface AttemptAcceptanceStatusResult {
+    acceptance: null | {
+        attemptId: string;
+        decision: "accepted" | "rejected";
+        attemptRevision: number;
+        policyId: typeof STRICT_ATTEMPT_ACCEPTANCE_POLICY_ID;
+        policyVersion: typeof STRICT_ATTEMPT_ACCEPTANCE_POLICY_VERSION;
+        reasonCodes: string[];
+        appliedAt: string;
+    };
+}
+
+type FanoutServiceStore = AgentWorkFanoutStore & WorkspaceLifecycleStore & AttemptReceiptStore & AttemptVerificationStore;
+interface CreateAgentWorkFanoutInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+    plan: AgentWorkFanoutPlan_v1;
+}
+interface DecideAgentWorkFanInInput {
+    runId: string;
+    expectedRunRevision: number;
+    controller: ControllerLeaseCredential;
+    mutationId: string;
+    now: string;
+    fanoutId: string;
+    decisionId: string;
+    diagnostics?: boolean;
+}
+type AgentWorkFanInResult = {
+    recorded: true;
+    decisionId: string;
+    outcome: "selected" | "escalated" | "no_viable_candidate";
+    selectedAttemptId?: string;
+    candidateCount: number;
+    evidenceSetHash: string;
+    idempotentReplay: boolean;
+    diagnostics?: {
+        conflicts: string[];
+        uncertainty: string[];
+        summary: string;
+    };
+} | {
+    recorded: false;
+    reason: Extract<FanInDecisionMutationResult, {
+        recorded: false;
+    }>["reason"];
+};
+/** Shared application boundary for bounded fanout declarations and deterministic engine fan-in. */
+declare class AgentWorkFanoutService {
+    private readonly store;
+    constructor(store: FanoutServiceStore);
+    create(input: CreateAgentWorkFanoutInput): Promise<FanoutPlanMutationResult>;
+    binding(fanoutId: string, attemptId: string): Promise<ReturnType<typeof FanoutAttemptBinding_v1.parse> | null>;
+    decide(input: DecideAgentWorkFanInInput): Promise<AgentWorkFanInResult>;
+}
+
+type Preparation = NonNullable<AgentTaskPacket_v1["preparation"]>;
+type PreparationStep = Preparation["steps"][number];
+interface AgentWorkPreparationCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    /** The adapter must attest that it enforced the exact packet-owned policy. */
+    policyHash: string;
+}
+interface AgentWorkPreparationCommandRunner {
+    run(input: {
+        argv: string[];
+        cwd: string;
+        policy: Preparation["policy"];
+        policyHash: string;
+    }): Promise<AgentWorkPreparationCommandResult>;
+}
+interface ExecuteAgentWorkPreparationInput {
+    packet: AgentTaskPacket_v1;
+    worktreeRoot: string;
+    receiptId: string;
+    runner: AgentWorkPreparationCommandRunner;
+    now(): string;
+}
+interface AgentWorkPreparationResult {
+    ok: boolean;
+    receipt: AgentWorkPreparationReceipt_v1;
+    failedStepId?: string;
+}
+/** Stable dependency order for packet-owned preparation steps. */
+declare function orderAgentWorkPreparationSteps(preparation: Preparation): PreparationStep[];
+/** Executes only the explicit preparation phase and emits hashes, never command logs. */
+declare function executeAgentWorkPreparation(input: ExecuteAgentWorkPreparationInput): Promise<AgentWorkPreparationResult>;
+
+interface AttemptReceiptStatusResult {
+    receipt: AttemptReceiptStatusProjection | null;
+}
+type AttemptReceiptSubmissionAcknowledgement = {
+    submitted: true;
+    receiptId: string;
+    receiptHash: string;
+    attemptId: string;
+    outcome: AgentTaskReceiptOutcome;
+    disposition: AttemptReceiptDisposition;
+    attemptRevision: number;
+    attemptStatus: AttemptStatus;
+    event: {
+        type: AttemptReceiptEventType;
+        sequence: number;
+        createdAt: string;
+    };
+    idempotentReplay: boolean;
+} | Extract<AttemptReceiptSubmissionResult, {
+    submitted: false;
+}>;
+/** Prompt-safe metadata for a durable worker claim; receipt JSON stays in the store. */
+interface AttemptReceiptStatusProjection {
+    receiptId: string;
+    receiptHash: string;
+    schemaVersion: string;
+    runId: string;
+    workItemId: string;
+    workItemRevision: number;
+    attemptId: string;
+    packetId: string;
+    packetHash: string;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    workerSessionId: string;
+    workerSessionRevision: number;
+    workerRuntime: string;
+    observedBaseSha: string;
+    finalHeadSha?: string;
+    patchHash?: string;
+    outcome: AgentTaskReceiptOutcome;
+    disposition: AttemptReceiptDisposition;
+    summary: string;
+    workerStartedAt: string;
+    workerCompletedAt: string;
+    submittedAt: string;
+    recordedAt: string;
+    counts: {
+        filesTouched: number;
+        commits: number;
+        claimedChecks: number;
+        blockers: number;
+    };
+}
+
+declare const AttemptReceiptSubmitRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    submission: z.ZodObject<{
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        expectedWorkerSessionRevision: z.ZodNumber;
+        receipt: z.ZodObject<{
+            schema_version: z.ZodLiteral<"2.0.0">;
+            receipt_id: z.ZodString;
+            run_id: z.ZodString;
+            work_item_id: z.ZodString;
+            work_item_revision: z.ZodNumber;
+            attempt_id: z.ZodString;
+            packet_id: z.ZodString;
+            packet_hash: z.ZodString;
+            workspace_lease_id: z.ZodString;
+            workspace_lease_revision: z.ZodNumber;
+            worker_runtime: z.ZodString;
+            worker_session_id: z.ZodString;
+            observed_base_sha: z.ZodString;
+            final_head_sha: z.ZodOptional<z.ZodString>;
+            patch_hash: z.ZodOptional<z.ZodString>;
+            outcome: z.ZodEnum<{
+                blocked: "blocked";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+            }>;
+            exit_reason: z.ZodString;
+            summary: z.ZodString;
+            files_touched: z.ZodArray<z.ZodString>;
+            commits: z.ZodArray<z.ZodString>;
+            acceptance_criteria_addressed: z.ZodArray<z.ZodString>;
+            claimed_checks: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                outcome: z.ZodEnum<{
+                    pass: "pass";
+                    fail: "fail";
+                    not_run: "not_run";
+                }>;
+                exit_code: z.ZodOptional<z.ZodNumber>;
+                output_snippet: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            assumptions: z.ZodArray<z.ZodString>;
+            blockers: z.ZodArray<z.ZodString>;
+            human_action_request_ids: z.ZodArray<z.ZodString>;
+            cost: z.ZodObject<{
+                input_tokens: z.ZodOptional<z.ZodNumber>;
+                output_tokens: z.ZodOptional<z.ZodNumber>;
+                tool_calls: z.ZodOptional<z.ZodNumber>;
+                elapsed_ms: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            worker_started_at: z.ZodString;
+            worker_completed_at: z.ZodString;
+            submitted_at: z.ZodString;
+        }, z.core.$strict>;
+        mutation: z.ZodObject<{
+            mutationId: z.ZodString;
+            now: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptReceiptStatusRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strict>>;
+interface AttemptReceiptHandlers {
+    submit(request: unknown): Promise<AgentWorkHandlerResult<AttemptReceiptSubmissionAcknowledgement>>;
+    status(request: unknown): Promise<AgentWorkHandlerResult<AttemptReceiptStatusResult>>;
+}
+declare function createAttemptReceiptHandlers(): AttemptReceiptHandlers;
+
+declare const AttemptVerificationRunRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    verification: z.ZodObject<{
+        beginMutationId: z.ZodString;
+        completeMutationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        verificationId: z.ZodString;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        expectedWorkerSessionRevision: z.ZodNumber;
+        receiptId: z.ZodString;
+        receiptHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptVerificationStatusRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodString;
+    diagnostics: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
+declare const AttemptAcceptanceApplyRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    acceptance: z.ZodObject<{
+        verificationHash: z.ZodString;
+        mutationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRunRevision: z.ZodNumber;
+        controller: z.ZodObject<{
+            runId: z.ZodString;
+            controllerId: z.ZodString;
+            leaseId: z.ZodString;
+            fencingToken: z.ZodNumber;
+        }, z.core.$strict>;
+        verificationId: z.ZodString;
+        attemptId: z.ZodString;
+        expectedAttemptRevision: z.ZodNumber;
+        workspaceLeaseId: z.ZodString;
+        expectedWorkspaceLeaseRevision: z.ZodNumber;
+        workerSessionId: z.ZodString;
+        expectedWorkerSessionRevision: z.ZodNumber;
+        receiptId: z.ZodString;
+        receiptHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const AttemptAcceptanceStatusRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    databasePath: z.ZodString;
+    runId: z.ZodString;
+    attemptId: z.ZodString;
+}, z.core.$strict>>;
+interface AttemptVerificationHandlers {
+    run(request: unknown): Promise<AgentWorkHandlerResult<AttemptVerificationRunResult>>;
+    status(request: unknown): Promise<AgentWorkHandlerResult<AttemptVerificationStatusResult>>;
+    applyAcceptance(request: unknown): Promise<AgentWorkHandlerResult<AttemptAcceptanceResult>>;
+    acceptanceStatus(request: unknown): Promise<AgentWorkHandlerResult<AttemptAcceptanceStatusResult>>;
+}
+interface AttemptVerificationHandlerOptions {
+    runtime?: AttemptVerificationRuntime;
+    now?: () => string;
+}
+declare function createAttemptVerificationHandlers(options?: AttemptVerificationHandlerOptions): AttemptVerificationHandlers;
+
+/**
+ * Compute merge order levels using Kahn's algorithm with deterministic ordering
+ * Returns array of levels, where each level contains item names that can be processed in parallel
+ */
+declare function computeMergeOrder(plan: Plan): string[][];
+
+/**
+ * GitHub API integration for PR discovery and metadata extraction
+ * Maintains deterministic ordering and stable output
+ * Includes error recovery with retry and circuit breaker patterns
+ */
+
+interface GitHubPullRequest {
+    number: number;
+    title: string;
+    branch: string;
+    sha: string;
+    state: "open" | "closed" | "merged";
+    labels: string[];
+    author: string;
+    baseBranch: string;
+    createdAt: string;
+    updatedAt: string;
+    mergeable?: boolean;
+    body?: string | null;
+    draft?: boolean;
+    reviewRequested?: boolean;
+}
+interface GitHubConfig {
+    token?: string;
+    owner: string;
+    repo: string;
+}
+/**
+ * GitHub API client for PR operations with error recovery
+ */
+declare class GitHubAPI {
+    private octokit;
+    config: GitHubConfig;
+    private circuitBreaker;
+    private normalized;
+    constructor(config: GitHubConfig);
+    /**
+     * Get the underlying Octokit instance for advanced operations
+     * Use with caution - prefer using typed methods when available
+     */
+    getOctokit(): Octokit;
+    /**
+     * Normalize repository owner and name to match GitHub's canonical casing.
+     * This handles case-insensitive lookups where git remote URLs may have
+     * different casing than the actual GitHub repository.
+     */
+    private normalizeRepositoryName;
+    /**
+     * Extract HTTP status code from error object
+     */
+    private extractErrorStatus;
+    /**
+     * Discover open pull requests with stable ordering and error recovery
+     */
+    discoverPullRequests(state?: "open" | "closed" | "all"): Promise<GitHubPullRequest[]>;
+    /**
+     * Get repository information
+     */
+    getRepositoryInfo(): Promise<{
+        name: string;
+        fullName: string;
+        defaultBranch: string;
+        private: boolean;
+    }>;
+    /**
+     * Check if authentication is working
+     */
+    checkAuth(): Promise<{
+        authenticated: boolean;
+        user?: string;
+    }>;
+    /**
+     * Get a specific pull request by number
+     */
+    getPullRequest(prNumber: number): Promise<GitHubPullRequest | null>;
+    /**
+     * Update a pull request (e.g., to undraft it)
+     */
+    updatePullRequest(owner: string, repo: string, prNumber: number, updates: {
+        draft?: boolean;
+        title?: string;
+        body?: string;
+    }): Promise<void>;
+    /**
+     * Add a label to a pull request
+     */
+    addLabel(prNumber: number, label: string): Promise<void>;
+    /**
+     * Remove a label from a pull request
+     */
+    removeLabel(prNumber: number, label: string): Promise<void>;
+    /**
+     * Get labels for a pull request
+     */
+    getLabels(prNumber: number): Promise<string[]>;
+    /**
+     * Get repository info (for harvest)
+     */
+    getRepository(): Promise<{
+        default_branch: string;
+        [key: string]: any;
+    }>;
+    /**
+     * Get a git reference (branch/tag SHA)
+     */
+    getRef(ref: string): Promise<{
+        object: {
+            sha: string;
+        };
+    }>;
+    /**
+     * Get check runs for a commit SHA
+     */
+    getCheckRuns(sha: string): Promise<{
+        total_count: number;
+        check_runs: Array<{
+            status: string;
+            conclusion: string | null;
+        }>;
+    }>;
+    /**
+     * Get reviews for a pull request
+     */
+    getReviews(prNumber: number): Promise<Array<{
+        user: {
+            login: string;
+        } | null;
+        state: string;
+    }>>;
+    /**
+     * Compare two commits
+     */
+    compare(base: string, head: string): Promise<{
+        merge_base_commit?: {
+            sha: string;
+        };
+    }>;
+    /**
+     * List issues (excluding PRs if filtered by caller)
+     */
+    listIssues(options: {
+        state: "open" | "closed" | "all";
+    }): Promise<any[]>;
+    /**
+     * Update a pull request's branch with the latest changes from the base branch
+     * This is typically used after merging another PR to keep branches up to date
+     */
+    updatePullRequestBranch(owner: string, repo: string, prNumber: number): Promise<void>;
+    /**
+     * Merge a pull request
+     */
+    mergePullRequest(owner: string, repo: string, prNumber: number, options: {
+        method: "squash" | "merge" | "rebase";
+        commitTitle?: string;
+    }): Promise<boolean>;
+    /**
+     * Get commit status for a SHA
+     */
+    getCommitStatus(owner: string, repo: string, ref: string): Promise<{
+        state: string;
+        statuses: any[];
+    }>;
+}
+/**
+ * Create GitHub API client from environment and config
+ */
+declare function createGitHubAPI(): Promise<GitHubAPI | null>;
+
+/**
+ * GitHub API integration types
+ * Defines data structures for PR metadata and repository information
+ */
+interface RepositoryInfo {
+    owner: string;
+    repo: string;
+    defaultBranch: string;
+    url: string;
+}
+interface PullRequest {
     number: number;
     title: string;
     body: string | null;
@@ -2455,7 +5640,7 @@ declare function createFileAnalyzer(octokit: Octokit, owner: string, repo: strin
  * Auto-discovers PRs and generates plan.json from GitHub metadata
  */
 
-interface GitHubPlanOptions {
+interface GitHubPlanOptions$1 {
     query?: string;
     labels?: string[];
     excludePRs?: number[];
@@ -2470,7 +5655,7 @@ interface GitHubPlanOptions {
 /**
  * Generate plan from GitHub PRs with automatic dependency resolution
  */
-declare function generatePlanFromGitHub(client: GitHubClient, options?: GitHubPlanOptions): Promise<Plan>;
+declare function generatePlanFromGitHub(client: GitHubClient, options?: GitHubPlanOptions$1): Promise<Plan>;
 
 /**
  * Multi-Repo Plan Generation
@@ -2493,7 +5678,7 @@ interface RepoTarget {
 /**
  * Options for multi-repo plan generation
  */
-interface MultiRepoPlanOptions {
+interface MultiRepoPlanOptions$1 {
     query?: string;
     labels?: string[];
     excludePRs?: number[];
@@ -2527,7 +5712,7 @@ interface MultiRepoPlanOptions {
  * });
  * ```
  */
-declare function generateMultiRepoPlan(repos: RepoTarget[], options?: MultiRepoPlanOptions): Promise<Plan>;
+declare function generateMultiRepoPlan(repos: RepoTarget[], options?: MultiRepoPlanOptions$1): Promise<Plan>;
 
 /**
  * Git operations for merge pyramid execution
@@ -2560,6 +5745,8 @@ declare class GitOperations {
     private git;
     private workingDir;
     constructor(workingDir?: string);
+    /** Repository-local execution root owned by this Git operations instance. */
+    getWorkingDirectory(): string;
     /**
      * Check if git repository is in a clean state
      */
@@ -2641,6 +5828,572 @@ declare function detectProjectType(baseDir?: string): string;
  */
 declare function getEnvironmentSuggestions(): string[];
 
+type GateExecutor = typeof executeGatesWithPolicy;
+interface GateExecutionServiceInput {
+    plan: Plan;
+    artifactDir: string;
+    timeoutMs?: number;
+    progressReporter?: Parameters<GateExecutor>[4];
+    skipValidation?: boolean;
+    repoRoot?: string;
+    options?: Parameters<GateExecutor>[7];
+    onlyItem?: string;
+    onlyGate?: string;
+    executionState?: ExecutionState;
+}
+interface BoundedGateRunResult {
+    contract: "bounded-ax-v1";
+    items: Array<{
+        name: string;
+        status: string;
+        gates: Array<{
+            name: string;
+            status: string;
+            failureKind?: "nonzero_exit" | "spawn_error" | "timeout";
+            timeoutCleanup?: {
+                method: "process-group" | "taskkill" | "direct-child";
+                forceKilled: boolean;
+                descendantsReaped: boolean;
+            };
+        }>;
+    }>;
+    allGreen: boolean;
+    artifactRefs: Array<{
+        kind: "gate-results-directory";
+        path: string;
+    }>;
+}
+interface GateExecutionServiceResult {
+    summary: BoundedGateRunResult;
+    executionState: ExecutionState;
+}
+declare class GateExecutionServiceError extends Error {
+    readonly code: "GATE_EXECUTION_FAILED" | "GATE_RESULT_LIMIT_EXCEEDED";
+    constructor(code: "GATE_EXECUTION_FAILED" | "GATE_RESULT_LIMIT_EXCEEDED", message: string);
+}
+/** One bounded transport-neutral owner for canonical CLI and MCP gate execution. */
+declare class GateExecutionService {
+    private readonly execute;
+    constructor(execute?: GateExecutor);
+    run(input: GateExecutionServiceInput): Promise<GateExecutionServiceResult>;
+}
+
+declare const GATE_IMPACT_MODEL: {
+    readonly version: "1.0.0";
+    readonly docsPrefixes: readonly ["docs/"];
+    readonly docsFiles: readonly ["README.md", "README.mcp.md"];
+    readonly fullSuitePrefixes: readonly [".github/", "schemas/", "scripts/", "src/mcp/", "src/sdk/", "src/store/", "tests/fixtures/", "tests/helpers/"];
+    readonly fullSuiteFiles: readonly ["mcp-server.mjs", ".npmrc", "CHANGELOG.md", "LICENSE.md", "NOTICE.md", "package.json", "package-lock.json", "src/cli.ts", "src/schema.ts", "tsconfig.json", "tsup.config.ts", "vitest.config.ts", "vitest.git.config.ts"];
+    readonly adjacentOwners: Record<string, string[]>;
+};
+type GateImpactMode = "focused" | "docs" | "full";
+interface GateImpactSelection {
+    schemaVersion: "1.0.0";
+    contract: "bounded-ax-v1";
+    modelVersion: string;
+    baseSha: string;
+    headSha: string;
+    mode: GateImpactMode;
+    changedFiles: string[];
+    selectedTests: Array<{
+        path: string;
+        rationale: string[];
+    }>;
+    staticCommands: string[];
+    testCommand: string;
+    documentationCommand?: string;
+    fallbackReason?: string;
+}
+declare class GateImpactServiceError extends Error {
+    readonly code: "GATE_IMPACT_INVALID_INPUT" | "GATE_IMPACT_DIFF_FAILED" | "GATE_IMPACT_RESULT_LIMIT_EXCEEDED";
+    constructor(code: "GATE_IMPACT_INVALID_INPUT" | "GATE_IMPACT_DIFF_FAILED" | "GATE_IMPACT_RESULT_LIMIT_EXCEEDED", message: string);
+}
+type ChangedFileLoader = (repoRoot: string, baseSha: string, headSha: string) => Promise<string[]>;
+/** Resolve a deterministic, conservative implementation-gate test selection. */
+declare class GateImpactService {
+    private readonly loadChangedFiles;
+    constructor(loadChangedFiles?: ChangedFileLoader);
+    select(input: {
+        repoRoot: string;
+        baseSha: string;
+        headSha: string;
+    }): Promise<GateImpactSelection>;
+}
+declare function applyGateImpactSelection(plan: Plan, selection: GateImpactSelection): Plan;
+declare function writeGateImpactReceipt(selection: GateImpactSelection, artifactDir: string): string;
+
+declare class IntegrationQueryServiceError extends Error {
+    readonly code: "QUERY_RESULT_LIMIT_EXCEEDED" | "PLAN_GENERATION_FAILED";
+    constructor(code: "QUERY_RESULT_LIMIT_EXCEEDED" | "PLAN_GENERATION_FAILED", message: string);
+}
+interface BoundedDiscoveryResult {
+    contract: "bounded-ax-v1";
+    pullRequests: Array<Omit<GitHubPullRequest, "body">>;
+    suggestions?: unknown[];
+    total: number;
+    suggestionsCount?: number;
+    authenticated: boolean;
+    user?: string;
+}
+declare class DiscoveryQueryService {
+    run(input: {
+        github: GitHubAPI;
+        state: "open" | "closed" | "all";
+        suggest?: boolean;
+    }): Promise<BoundedDiscoveryResult>;
+}
+type GitHubPlanOptions = Parameters<typeof generatePlanFromGitHub>[1];
+type MultiRepoPlanOptions = Parameters<typeof generateMultiRepoPlan>[1];
+declare class PlanCreationService {
+    fromGitHub(client: GitHubClient, options: GitHubPlanOptions): Promise<Plan>;
+    fromMultipleRepositories(repositories: RepoTarget[], options: MultiRepoPlanOptions): Promise<Plan>;
+    fromInputs(inputs: InputConfig, options?: {
+        tierOverrides?: TierOverride[];
+        preserveEmptyPlan?: boolean;
+    }): Plan;
+}
+interface BoundedIntegrationStatus {
+    contract: "bounded-ax-v1";
+    plan: {
+        schemaVersion: string;
+        target: string;
+        itemCount: number;
+        policy?: Plan["policy"];
+    };
+    mergeSummary: ReturnType<MergeEligibilityEvaluator["getMergeSummary"]>;
+}
+declare class IntegrationStatusQueryService {
+    run(plan: Plan): BoundedIntegrationStatus;
+}
+interface BoundedMergeOrderResult {
+    contract: "bounded-ax-v1";
+    levels: string[][];
+    totalItems: number;
+    maxParallelism: number;
+}
+declare class MergeOrderQueryService {
+    run(plan: Plan): BoundedMergeOrderResult;
+}
+
+/**
+ * Checkpoint types for merge-weave resume support
+ */
+
+type ResumeOperationStatus = "pending" | "in_progress" | "completed" | "failed";
+/** One durable, independently reconcilable operation in a resumable weave. */
+interface ResumeOperation {
+    id: string;
+    phase: "gate" | "merge" | "post_check";
+    item: string;
+    status: ResumeOperationStatus;
+    attempts: number;
+    startedAt?: string;
+    completedAt?: string;
+    result?: {
+        outcome: "executed" | "observed";
+        externalId?: string;
+    };
+    error?: string;
+}
+
+type ResumeWeaveResult = {
+    ok: true;
+    outcome: "completed" | "paused";
+    runId: string;
+    revision: number;
+    completed: number;
+    pending: number;
+    failed: number;
+} | {
+    ok: false;
+    code: "checkpoint_busy" | "checkpoint_invalid" | "external_state_mismatch" | "ambiguous_external_state" | "operation_failed";
+    runId: string;
+    reason: string;
+    operationId?: string;
+};
+
+type MergeApplicationFailureCode = "MERGE_MUTATION_DENIED" | "MERGE_STALE_INPUT" | "MERGE_CONFLICT" | "MERGE_APPLICATION_FAILED";
+declare class MergeApplicationServiceError extends Error {
+    readonly code: MergeApplicationFailureCode;
+    constructor(code: MergeApplicationFailureCode, message: string);
+}
+interface BoundedMergeApplicationResult {
+    contract: "bounded-ax-v1";
+    mode: "dry-run" | "execute";
+    /** Compatibility projection retained for existing CLI/MCP JSON consumers. */
+    dryRun: boolean;
+    ok: boolean;
+    status: "preview" | "completed" | "paused" | "failed";
+    totalItems: number;
+    levels?: string[][];
+    maxParallelism?: number;
+    runId?: string;
+    operations?: Array<{
+        id: string;
+        phase: string;
+        item: string;
+        status: string;
+        evidenceRef?: string;
+    }>;
+    artifactRefs: Array<{
+        kind: "weave-checkpoint";
+        id: string;
+    }>;
+    failureCode?: MergeApplicationFailureCode;
+}
+interface MergeApplicationExecution {
+    result: ResumeWeaveResult;
+    operations: ResumeOperation[];
+}
+interface MergeApplicationRuntime {
+    isClean(workingDir: string): Promise<boolean>;
+    prepare(plan: Plan, workingDir: string): Promise<string>;
+    resume(runId: string, workingDir: string): Promise<MergeApplicationExecution>;
+}
+declare class MergeApplicationService {
+    private readonly runtime;
+    constructor(runtime?: MergeApplicationRuntime);
+    run(input: {
+        plan: Plan;
+        workingDir: string;
+        dryRun: boolean;
+        mutationAuthorized: boolean;
+    }): Promise<{
+        summary: BoundedMergeApplicationResult;
+        execution?: MergeApplicationExecution;
+    }>;
+    executePrepared(input: {
+        plan: Plan;
+        workingDir: string;
+        runId: string;
+    }): Promise<{
+        summary: BoundedMergeApplicationResult;
+        execution: MergeApplicationExecution;
+    }>;
+}
+
+/**
+ * Environmental Hostility Scoring
+ *
+ * Implements Definition 3.2 (Environmental Hostility) from the governance thesis:
+ * The degree to which an environment impedes effective agent operation through:
+ * - Unclear or implicit constraints
+ * - Opaque requirements (unstated expectations)
+ * - Unbounded problem surfaces
+ * - Missing receipts and traceability
+ * - Punitive error dynamics
+ * - Fragmented state
+ * - Model switches without continuity protocols
+ */
+
+/**
+ * Schema for the complete hostility score with all component breakdowns.
+ */
+declare const HostilityScoreSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    status: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    components: z.ZodObject<{
+        constraintClarity: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        requirementExplicitness: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        problemBoundedness: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        receiptCompleteness: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errorRecoverability: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        stateCoherence: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        modelContinuity: z.ZodObject<{
+            score: z.ZodNumber;
+            status: z.ZodEnum<{
+                critical: "critical";
+                warning: "warning";
+                good: "good";
+            }>;
+            details: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    recommendations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type HostilityScore = z.infer<typeof HostilityScoreSchema>;
+
+/**
+ * Environmental Hostility Checks
+ *
+ * Individual check functions for each hostility component.
+ * Each check examines a specific aspect of environment quality.
+ */
+
+/**
+ * Options for running hostility checks
+ */
+interface CheckOptions {
+    /** Current working directory for checks */
+    cwd?: string;
+    /** Path to plan.json file */
+    planPath?: string;
+    /** Profile directory path */
+    profileDir?: string;
+}
+
+/**
+ * Environmental Hostility Scoring Module
+ *
+ * Implements the Environmental De-hostilization concept from the coordination
+ * cost compression thesis (Definition 3.2).
+ *
+ * @module hostility
+ */
+
+/**
+ * Run a complete environment quality check and return the hostility score.
+ *
+ * @param options - Check options including cwd, planPath, and profileDir
+ * @returns Complete hostility score with component breakdown
+ */
+declare function runEnvironmentQualityCheck(options?: CheckOptions): HostilityScore;
+
+type WorkspaceConfigFailureCode = "WORKSPACE_INIT_FAILED" | "WORKSPACE_DIAGNOSTICS_FAILED" | "CONFIG_KEY_NOT_FOUND" | "CONFIG_RESULT_LIMIT_EXCEEDED" | "PROFILE_RESOLUTION_FAILED";
+declare class WorkspaceConfigServiceError extends Error {
+    readonly code: WorkspaceConfigFailureCode;
+    constructor(code: WorkspaceConfigFailureCode, message: string);
+}
+interface ConfigSourceLevel {
+    level: string;
+    path?: string;
+    checked: boolean;
+    found: boolean;
+    overridden?: boolean;
+}
+interface BoundedConfigValue {
+    key: string;
+    value: unknown;
+    source: string;
+    overrides?: {
+        source: string;
+        value: unknown;
+    };
+    precedence: ConfigSourceLevel[];
+}
+interface BoundedConfigResult {
+    contract: "bounded-ax-v1";
+    precedenceChain: Array<{
+        level: string;
+        source?: string;
+        path?: string;
+    }>;
+    configuration: BoundedConfigValue[];
+}
+interface BoundedWorkspaceInitResult extends LocalOverlayResult {
+    contract: "bounded-ax-v1";
+}
+interface BoundedProfileResult {
+    contract: "bounded-ax-v1";
+    path: string;
+    source: string;
+    manifest: ResolvedProfile["manifest"];
+}
+interface BoundedDoctorResult {
+    contract: "bounded-ax-v1";
+    hasErrors: boolean;
+    issues: string[];
+    suggestions: string[];
+    nodejs: {
+        status: "ok" | "mismatch" | "no_constraint";
+        current: string;
+        required: string;
+        expected?: string;
+    };
+    configuration: ReturnType<typeof bootstrapWorkspace>;
+    projectType: string;
+    environmentSuggestions: string[];
+    github?: {
+        detected: boolean;
+        authenticated?: boolean;
+        user?: string;
+        error?: string;
+    };
+    git?: {
+        status: "ok" | "error";
+        isClean?: boolean;
+        currentBranch?: string;
+        error?: string;
+    };
+    environmentQuality?: ReturnType<typeof runEnvironmentQualityCheck>;
+}
+/** Transport-neutral owner for deterministic workspace initialization. */
+declare class WorkspaceInitializationService {
+    run(input: {
+        baseDir: string;
+        force?: boolean;
+    }): BoundedWorkspaceInitResult;
+}
+/** Transport-neutral owner for workspace and environment diagnostics. */
+declare class WorkspaceDiagnosticsService {
+    run(input: {
+        baseDir: string;
+        environmentQuality?: boolean;
+    }): Promise<BoundedDoctorResult>;
+}
+/** Transport-neutral owner for configuration and profile queries. */
+declare class ConfigurationQueryService {
+    show(input: {
+        baseDir: string;
+        key?: string;
+    }): BoundedConfigResult;
+    resolveProfile(input: {
+        baseDir: string;
+        profileDir?: string;
+    }): BoundedProfileResult;
+}
+
+declare const INTEGRATION_RECORD_REMOVAL_VERSION: "2.0.0";
+declare const INTEGRATION_RECORD_REPLACEMENTS: {
+    readonly "lexrunner.startRun": "plan.create, gates.run, or merge.apply for integration; start_attempt for ADR-010 orchestration";
+    readonly "lexrunner.getStatus": "status for integration; get_attempt_status for ADR-010 orchestration";
+    readonly "lexrunner.listArtifacts": "bounded artifact references from the owning plan.create, gates.run, or merge.apply operation";
+};
+type IntegrationRecordCompatibilityTool = keyof typeof INTEGRATION_RECORD_REPLACEMENTS;
+type IntegrationRecordCompatibilityFailureCode = "INTEGRATION_RECORD_INVALID_INPUT" | "INTEGRATION_RECORD_NOT_FOUND" | "INTEGRATION_RECORD_RESULT_LIMIT_EXCEEDED" | "INTEGRATION_RECORD_OPERATION_FAILED";
+declare class IntegrationRecordCompatibilityError extends Error {
+    readonly code: IntegrationRecordCompatibilityFailureCode;
+    constructor(code: IntegrationRecordCompatibilityFailureCode, message: string);
+}
+interface StartIntegrationRecordInput {
+    mode: string;
+    procedure: string;
+    repo: string;
+    task?: string;
+    params?: Record<string, unknown>;
+}
+interface ListIntegrationArtifactsInput {
+    runId: string;
+    type?: ArtifactType;
+    path?: string;
+    latestOnly?: boolean;
+    inline?: boolean;
+}
+interface CompatibilityMetadata {
+    contract: "bounded-ax-v1";
+    kind: "IntegrationRun";
+    authority: "integration-record-only";
+    deprecation: {
+        tool: IntegrationRecordCompatibilityTool;
+        replacement: string;
+        removeIn: typeof INTEGRATION_RECORD_REMOVAL_VERSION;
+    };
+}
+/**
+ * Bounded retirement adapter for the legacy lexrunner.* integration-record tools.
+ * It never receives a CoordinationStore and cannot advance ADR-010 WorkItem/Run/Attempt state.
+ */
+declare class IntegrationRecordCompatibilityService {
+    private readonly manager;
+    constructor(baseDir?: string);
+    start(input: StartIntegrationRecordInput): CompatibilityMetadata & {
+        runId: string;
+        status: string;
+        message: string;
+        initialStatus: {
+            runId: string;
+            state: string;
+            mode: string;
+            procedure: string;
+            summary: string;
+            progress: unknown;
+            nextOptions: unknown[];
+        };
+    };
+    getStatus(input: {
+        runId: string;
+    }): CompatibilityMetadata & ReturnType<typeof projectStatus>;
+    listArtifacts(input: ListIntegrationArtifactsInput): CompatibilityMetadata & {
+        artifacts: Array<{
+            path: string;
+            type: ArtifactType;
+            size: number;
+            createdAt: string;
+            modifiedAt: string;
+        }>;
+        totalCount: number;
+        returnedCount: number;
+        truncated: boolean;
+        inlineContentRetired: true;
+    };
+}
+declare function projectStatus(status: {
+    runId: string;
+    state: string;
+    mode: string;
+    procedure: string;
+    summary: string;
+    progress?: unknown;
+    nextOptions?: unknown[];
+}): {
+    runId: string;
+    state: string;
+    mode: string;
+    procedure: string;
+    summary: string;
+    progress: unknown;
+    nextOptions: unknown[];
+};
+
 /**
  * Guided workflow response types for MCP server
  *
@@ -2704,6 +6457,8 @@ type WorkflowPhase = "initial" | "post-plan-creation" | "post-gates-run" | "pre-
  */
 declare function createWorkflowGuide(phase: WorkflowPhase): WorkflowGuide;
 
+/** Architecture-test hook; returns metadata only and never executes a command. */
+declare function inspectRegisteredCliSurface(): RegisteredCliCommand[];
 declare function main(argv?: string[]): Promise<void>;
 
-export { ExecutionState, GitHubAPI, MergeEligibilityEvaluator, type MultiRepoPlanOptions, type RepoTarget, bootstrapWorkspace, canonicalJSONStringify, computeMergeOrder, createFileAnalyzer, createGitHubAPI, createGitHubClient, createGitOperations, createRunManager, createWorkflowGuide, detectProjectType, executeGatesWithPolicy, generateGitHubSnapshot, generateMultiRepoPlan, generatePlan, generatePlanFromGitHub, generateSnapshot, getEnvironmentSuggestions, healthChecker, initLocalOverlay, loadInputs, loadPlan, main, resolveProfile };
+export { AGENT_ENGINE_VERIFICATION_V2_VERSION, AGENT_TASK_RECEIPT_PATCH_PROFILE, AGENT_TASK_RECEIPT_V2_VERSION, AGENT_WORK_CONTRACT_VERSION, AgentEngineVerification_v1, AgentEngineVerification_v2, type AgentTaskPacketHashInput, AgentTaskPacketHashInput_v1, AgentTaskPacket_v1, type AgentTaskReceiptBindingContext, AgentTaskReceiptOutcome, type AgentTaskReceiptV2BindingContext, AgentTaskReceipt_v1, AgentTaskReceipt_v2, AgentWorkFanInDecision_v1, type AgentWorkFanInResult, AgentWorkFanoutPlan_v1, AgentWorkFanoutService, type AgentWorkPreparationCommandResult, type AgentWorkPreparationCommandRunner, AgentWorkPreparationReceipt_v1, type AgentWorkPreparationResult, AttemptAcceptanceApplyRequestJsonSchema, AttemptAcceptanceStatusRequestJsonSchema, AttemptPrepareRequestJsonSchema, AttemptReceiptStatusRequestJsonSchema, AttemptReceiptSubmitRequestJsonSchema, AttemptRetryDeltaDimension_v1, AttemptRetryDelta_v1, AttemptStartRequestJsonSchema, AttemptStatus, AttemptStatusInputJsonSchema, AttemptVerificationRunRequestJsonSchema, AttemptVerificationStatusRequestJsonSchema, AttemptWorkerAttachRequestJsonSchema, AttemptWorkerEndRequestJsonSchema, AttemptWorkerHeartbeatRequestJsonSchema, AttemptWorkerStatusRequestJsonSchema, Attempt_v1, AuthorityEnvelope, type BoundedDiscoveryResult, type BoundedGateRunResult, type BoundedIntegrationStatus, type BoundedMergeApplicationResult, type BoundedMergeOrderResult, ClaimedCheckOutcome, ConfigurationQueryService, ControllerLease_v1, type CreateAgentWorkFanoutInput, type DecideAgentWorkFanInInput, DiscoveryQueryService, EngineVerificationCheckSource_v2, EngineVerificationDeterminism_v2, EngineVerificationTrustGapReason_v2, type ExecuteAgentWorkPreparationInput, ExecutionEnvelope_v1, ExecutionEnvironmentOS, ExecutionState, FanInCandidateConclusion_v1, FanoutAttemptBinding_v1, FanoutPremise_v1, FanoutRationale_v1, FanoutSelectionCriterion_v1, GATE_IMPACT_MODEL, GateExecutionService, GateExecutionServiceError, type GateExecutionServiceInput, type GateExecutionServiceResult, GateImpactService, GateImpactServiceError, GitHubAPI, GitObjectId, HumanActionPreconditions, HumanActionReceipt_v1, HumanActionRequest_v1, INTEGRATION_RECORD_REMOVAL_VERSION, INTEGRATION_RECORD_REPLACEMENTS, IntegrationQueryServiceError, IntegrationRecordCompatibilityError, IntegrationRecordCompatibilityService, IntegrationStatusQueryService, type MergeApplicationExecution, type MergeApplicationFailureCode, type MergeApplicationRuntime, MergeApplicationService, MergeApplicationServiceError, MergeEligibilityEvaluator, MergeOrderQueryService, type MultiRepoPlanOptions$1 as MultiRepoPlanOptions, PlanCreationService, type RepoTarget, RunStatus, Run_v1, STRICT_FANOUT_SELECTION_CRITERIA, VerificationOutcome, WorkItem_v1, WorkerSessionBackend, WorkerSessionStatus, WorkerSession_v1, WorkspaceAllocationStatus, WorkspaceAllocation_v1, WorkspaceCleanupDisposition, WorkspaceConfigServiceError, WorkspaceDiagnosticsService, WorkspaceInitializationService, WorkspaceLeaseStatus, WorkspaceLease_v1, applyGateImpactSelection, attemptStatusRequiresReceipt, attemptStatusRequiresVerification, bootstrapWorkspace, canonicalJSONStringify, computeAgentEngineVerificationV2Hash, computeAgentTaskPacketHash, computeFanInEvidenceSetHash, computeMergeOrder, createAgentTaskPacket, createAttemptLifecycleHandlers, createAttemptReceiptHandlers, createAttemptVerificationHandlers, createAttemptWorkerHandlers, createFileAnalyzer, createGitHubAPI, createGitHubClient, createGitOperations, createRunManager, createWorkflowGuide, detectProjectType, executeAgentWorkPreparation, executeGatesWithPolicy, generateGitHubSnapshot, generateMultiRepoPlan, generatePlan, generatePlanFromGitHub, generateSnapshot, getEnvironmentSuggestions, healthChecker, initLocalOverlay, inspectRegisteredCliSurface, isTerminalAttemptStatus, loadInputs, loadPlan, main, orderAgentWorkPreparationSteps, parseAgentEngineVerification, parseAgentEngineVerificationV2, parseAgentTaskPacket, parseAgentTaskReceipt, parseAgentTaskReceiptV2, parseAttempt, parseControllerLease, parseExecutionEnvelope, parseHumanActionReceipt, parseHumanActionRequest, parseRun, parseWorkItem, parseWorkerSession, parseWorkspaceAllocation, parseWorkspaceLease, resolveProfile, validateAgentEngineVerificationV2PacketReferences, validateAgentTaskReceiptBinding, validateAgentTaskReceiptV2Binding, validateAgentTaskReceiptV2PacketReferences, validateHumanActionReceiptBinding, writeGateImpactReceipt };