@smartergpt/lexrunner 1.4.1 → 1.5.2

package/dist/cli.d.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { AXErrorException } from '@smartergpt/lex/errors';
 import { F as FrameOutcome, a as FrameEmitResult } from './types-CYMIAhy8.js';
 export { m as mcpToolError } from './adapters-r7_TjMwo.js';
+import { Database } from 'better-sqlite3-multiple-ciphers';
 import { Octokit } from '@octokit/rest';
 
 /**
@@ -25,6 +26,7 @@ declare const GateResult: z.ZodObject<{
         nonzero_exit: "nonzero_exit";
         spawn_error: "spawn_error";
         timeout: "timeout";
+        evidence_error: "evidence_error";
     }>>;
     timeoutCleanup: z.ZodOptional<z.ZodObject<{
         method: z.ZodEnum<{
@@ -69,6 +71,7 @@ declare const NodeResult: z.ZodObject<{
             nonzero_exit: "nonzero_exit";
             spawn_error: "spawn_error";
             timeout: "timeout";
+            evidence_error: "evidence_error";
         }>>;
         timeoutCleanup: z.ZodOptional<z.ZodObject<{
             method: z.ZodEnum<{
@@ -1904,6 +1907,97 @@ interface ControllerLeaseCredential {
     leaseId: string;
     fencingToken: number;
 }
+interface RunCoordinationRecord {
+    runId: string;
+    revision: number;
+    state: JsonValue;
+    updatedAt: string;
+    lease: ControllerLease | null;
+}
+interface AcquireControllerLeaseInput {
+    runId: string;
+    controllerId: string;
+    /** Caller-generated ID, making an uncertain acquisition retry idempotent. */
+    leaseId: string;
+    /** Explicit clock input keeps lease behavior deterministic in tests/replay. */
+    now: string;
+    ttlMs: number;
+    /** Used only when this is the first coordination record for the run. */
+    initialState: JsonValue;
+}
+interface RenewControllerLeaseInput extends ControllerLeaseCredential {
+    now: string;
+    ttlMs: number;
+}
+type ReleaseControllerLeaseInput = ControllerLeaseCredential;
+interface CompareAndSetRunStateInput extends ControllerLeaseCredential {
+    expectedRevision: number;
+    /** Stable caller-generated key for uncertain mutation retries. */
+    mutationId: string;
+    state: JsonValue;
+    event: RunCoordinationEventInput;
+    now: string;
+}
+interface RunCoordinationEventInput {
+    type: string;
+    payload: JsonValue;
+}
+/** Authoritative event committed atomically with its resulting run revision. */
+interface RunCoordinationEvent extends RunCoordinationEventInput {
+    runId: string;
+    mutationId: string;
+    revision: number;
+    expectedRevision: number;
+    controllerId: string;
+    leaseId: string;
+    fencingToken: number;
+    createdAt: string;
+    /** Exact state committed by this mutation, retained for faithful replay. */
+    resultingState: JsonValue;
+}
+type LeaseFailureReason = "held_by_other" | "not_found" | "no_active_lease" | "lease_mismatch" | "stale_fence" | "lease_expired";
+type AcquireControllerLeaseResult = {
+    acquired: true;
+    lease: ControllerLease;
+    record: RunCoordinationRecord;
+} | {
+    acquired: false;
+    reason: "held_by_other";
+    currentLease: ControllerLease;
+};
+type RenewControllerLeaseResult = {
+    renewed: true;
+    lease: ControllerLease;
+} | {
+    renewed: false;
+    reason: Exclude<LeaseFailureReason, "held_by_other">;
+};
+type ReleaseControllerLeaseResult = {
+    released: true;
+} | {
+    released: false;
+    reason: Exclude<LeaseFailureReason, "held_by_other" | "lease_expired">;
+};
+type CompareAndSetRunStateResult = {
+    updated: true;
+    record: RunCoordinationRecord;
+    event: RunCoordinationEvent;
+    idempotentReplay: boolean;
+} | {
+    updated: false;
+    reason: Exclude<LeaseFailureReason, "held_by_other"> | "stale_revision" | "mutation_conflict";
+    currentRevision?: number;
+};
+interface CoordinationStore {
+    acquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewControllerLease(input: RenewControllerLeaseInput): Promise<RenewControllerLeaseResult>;
+    releaseControllerLease(input: ReleaseControllerLeaseInput): Promise<ReleaseControllerLeaseResult>;
+    getControllerLease(runId: string): Promise<ControllerLease | null>;
+    getRunCoordination(runId: string): Promise<RunCoordinationRecord | null>;
+    listRunCoordinationEvents(runId: string): Promise<RunCoordinationEvent[]>;
+    compareAndSetRunState(input: CompareAndSetRunStateInput): Promise<CompareAndSetRunStateResult>;
+    close(): Promise<void>;
+}
 
 /**
  * Agent work protocol contracts.
@@ -2883,8 +2977,8 @@ declare const WorkspaceAllocation_v1: z.ZodObject<{
         observed_at: z.ZodString;
     }, z.core.$strict>>;
     quarantine_reason: z.ZodOptional<z.ZodEnum<{
-        other: "other";
         missing: "missing";
+        other: "other";
         dirty: "dirty";
         expired: "expired";
         unregistered: "unregistered";
@@ -3547,6 +3641,35 @@ declare const AttemptVerificationEventType: z.ZodEnum<{
     attempt_verification_replayed: "attempt_verification_replayed";
 }>;
 type AttemptVerificationEventType = z.infer<typeof AttemptVerificationEventType>;
+declare const WorkerAuthorityDimension: z.ZodEnum<{
+    release: "release";
+    edit: "edit";
+    git_write: "git_write";
+    github_write: "github_write";
+    external_runtime: "external_runtime";
+    secrets: "secrets";
+    signing: "signing";
+}>;
+type WorkerAuthorityDimension = z.infer<typeof WorkerAuthorityDimension>;
+declare const WorkerAuthorityDecision: z.ZodEnum<{
+    allowed: "allowed";
+    denied: "denied";
+    deviation: "deviation";
+}>;
+type WorkerAuthorityDecision = z.infer<typeof WorkerAuthorityDecision>;
+declare const WorkerAuthorityEnforcement: z.ZodEnum<{
+    brokered: "brokered";
+    enforced: "enforced";
+    unenforced: "unenforced";
+}>;
+type WorkerAuthorityEnforcement = z.infer<typeof WorkerAuthorityEnforcement>;
+declare const WorkerAuthorityReason: z.ZodEnum<{
+    packet_granted: "packet_granted";
+    packet_denied: "packet_denied";
+    backend_unenforceable: "backend_unenforceable";
+    observed_after_execution: "observed_after_execution";
+}>;
+type WorkerAuthorityReason = z.infer<typeof WorkerAuthorityReason>;
 declare const WorkspaceMutationFailureReason: z.ZodEnum<{
     not_found: "not_found";
     no_active_lease: "no_active_lease";
@@ -3861,6 +3984,24 @@ interface LaunchEnvelopeBindingRecord {
     fencingToken: number;
     createdAt: string;
 }
+/**
+ * Immutable canonical AgentTaskPacket snapshot bound to the durable Attempt.
+ *
+ * The snapshot is written only as part of launch-envelope binding, so callers
+ * cannot make a packet body appear after a worker has started.  It deliberately
+ * retains the canonical JSON for later criterion/check reference validation;
+ * consumers must parse it under AgentTaskPacket_v1 before acting on it.
+ */
+interface TaskPacketBindingRecord {
+    runId: string;
+    attemptId: string;
+    workItemId: string;
+    workItemRevision: number;
+    packetId: string;
+    packetHash: string;
+    packetJson: string;
+    createdAt: string;
+}
 interface WorkerSessionEvent {
     runId: string;
     attemptId: string;
@@ -3877,6 +4018,32 @@ interface WorkerSessionEvent {
     payload: JsonValue;
     createdAt: string;
 }
+/** Redacted packet-authority decision made immediately before, or observed after, worker action. */
+interface WorkerAuthorityEventRecord {
+    runId: string;
+    attemptId: string;
+    workerSessionId: string;
+    mutationId: string;
+    sequence: number;
+    attemptRevision: number;
+    workspaceLeaseId: string;
+    workspaceLeaseRevision: number;
+    workerSessionRevision: number;
+    packetId: string;
+    packetHash: string;
+    dimension: WorkerAuthorityDimension;
+    decision: WorkerAuthorityDecision;
+    enforcement: WorkerAuthorityEnforcement;
+    actionClass: string;
+    actionHash: string;
+    backendId: string;
+    backendVersion: string;
+    reason: WorkerAuthorityReason;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    createdAt: string;
+}
 interface AuthenticatedMutationInput {
     runId: string;
     expectedRunRevision: number;
@@ -3890,6 +4057,34 @@ interface AuthenticatedWorkerMutationInput extends AuthenticatedMutationInput {
     expectedAttemptRevision: number;
     expectedWorkspaceLeaseRevision: number;
 }
+interface RecordWorkerAuthorityDecisionInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    expectedAttemptRevision: number;
+    workspaceLeaseId: string;
+    expectedWorkspaceLeaseRevision: number;
+    workerSessionId: string;
+    expectedWorkerSessionRevision: number;
+    dimension: WorkerAuthorityDimension;
+    decision: WorkerAuthorityDecision;
+    enforcement: WorkerAuthorityEnforcement;
+    actionClass: string;
+    actionHash: string;
+    backendId: string;
+    backendVersion: string;
+    reason: WorkerAuthorityReason;
+}
+type WorkerAuthorityDecisionResult = {
+    recorded: true;
+    event: WorkerAuthorityEventRecord;
+    idempotentReplay: boolean;
+} | {
+    recorded: false;
+    reason: WorkerSessionMutationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentSessionRevision?: number;
+    currentRunRevision?: number;
+};
 interface AttachWorkerSessionInput extends AuthenticatedWorkerMutationInput {
     sessionId: string;
     packetId: string;
@@ -4114,6 +4309,18 @@ interface SubmitAttemptVerificationInput {
 /** 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 ApplyAttemptAcceptanceInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    expectedAttemptRevision: number;
+    workspaceLeaseId: string;
+    expectedWorkspaceLeaseRevision: number;
+    workerSessionId: string;
+    expectedWorkerSessionRevision: number;
+    receiptId: string;
+    receiptHash: string;
+    verificationId: string;
+    verificationHash: string;
+}
 interface BeginAttemptVerificationInput {
     runId: string;
     expectedRunRevision: number;
@@ -4312,6 +4519,10 @@ interface LaunchEnvelopeBindingStore {
     reconcileIncompleteLaunch(input: ReconcileIncompleteLaunchInput): Promise<WorkspaceMutationResult>;
     getLaunchEnvelopeBinding(attemptId: string): Promise<LaunchEnvelopeBindingRecord | null>;
 }
+/** Read-only access to immutable task packet snapshots written during launch binding. */
+interface TaskPacketBindingStore {
+    getTaskPacketBinding(attemptId: string): Promise<TaskPacketBindingRecord | null>;
+}
 /** Additive Stage 3 persistence port; kept separate from the Stage 1 workspace contract. */
 interface WorkerSessionStore {
     attachWorkerSession(input: AttachWorkerSessionInput): Promise<WorkerSessionMutationResult>;
@@ -4322,6 +4533,11 @@ interface WorkerSessionStore {
     getWorkerAdapterBinding(sessionId: string): Promise<WorkerAdapterBindingRecord | null>;
     listWorkerSessionEvents(runId: string): Promise<WorkerSessionEvent[]>;
 }
+/** Additive audit port for packet-bound worker authority decisions. */
+interface WorkerAuthorityDecisionStore {
+    recordWorkerAuthorityDecision(input: RecordWorkerAuthorityDecisionInput): Promise<WorkerAuthorityDecisionResult>;
+    listWorkerAuthorityEvents(runId: string): Promise<WorkerAuthorityEventRecord[]>;
+}
 /** Additive immutable AgentTaskReceipt v2 persistence port. */
 interface AttemptReceiptStore {
     submitAttemptReceipt(input: SubmitAttemptReceiptInput): Promise<AttemptReceiptSubmissionResult>;
@@ -4341,6 +4557,10 @@ interface AttemptVerificationStore {
     getAttemptVerificationAuthorizationForAttempt(attemptId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
     listAttemptVerificationEvents(runId: string): Promise<AttemptVerificationEvent[]>;
 }
+/** Policy-owned transition from verified evidence to an accepted or rejected Attempt. */
+interface AttemptAcceptanceStore {
+    applyAttemptAcceptance(input: ApplyAttemptAcceptanceInput): Promise<WorkspaceMutationResult>;
+}
 
 interface WorktreeTarget extends WorkspaceIdentity {
     /** Immutable full Git object ID used to create this Attempt workspace. */
@@ -4694,9 +4914,9 @@ declare const SourceObservationShape: {
     readonly source_head_sha: z.ZodString;
     readonly requested_object_sha: z.ZodString;
     readonly requested_object_type: z.ZodEnum<{
+        missing: "missing";
         commit: "commit";
         other: "other";
-        missing: "missing";
     }>;
     readonly cleanliness: z.ZodEnum<{
         unknown: "unknown";
@@ -4714,9 +4934,9 @@ declare const NativeWslSourceObservation_v1: z.ZodPreprocess<z.ZodObject<{
     source_head_sha: z.ZodString;
     requested_object_sha: z.ZodString;
     requested_object_type: z.ZodEnum<{
+        missing: "missing";
         commit: "commit";
         other: "other";
-        missing: "missing";
     }>;
     cleanliness: z.ZodEnum<{
         unknown: "unknown";
@@ -4821,9 +5041,9 @@ declare const ProjectionManifestShape: {
         source_head_sha: z.ZodString;
         requested_object_sha: z.ZodString;
         requested_object_type: z.ZodEnum<{
+            missing: "missing";
             commit: "commit";
             other: "other";
-            missing: "missing";
         }>;
         cleanliness: z.ZodEnum<{
             unknown: "unknown";
@@ -4909,9 +5129,9 @@ declare const NativeWslProjectionManifest_v1: z.ZodPreprocess<z.ZodObject<{
         source_head_sha: z.ZodString;
         requested_object_sha: z.ZodString;
         requested_object_type: z.ZodEnum<{
+            missing: "missing";
             commit: "commit";
             other: "other";
-            missing: "missing";
         }>;
         cleanliness: z.ZodEnum<{
             unknown: "unknown";
@@ -5412,9 +5632,9 @@ declare const ProjectionSelectionShape: {
         source_head_sha: z.ZodString;
         requested_object_sha: z.ZodString;
         requested_object_type: z.ZodEnum<{
+            missing: "missing";
             commit: "commit";
             other: "other";
-            missing: "missing";
         }>;
         cleanliness: z.ZodEnum<{
             unknown: "unknown";
@@ -5476,9 +5696,9 @@ declare const NativeWslProjectionSelection_v1: z.ZodPreprocess<z.ZodObject<{
         source_head_sha: z.ZodString;
         requested_object_sha: z.ZodString;
         requested_object_type: z.ZodEnum<{
+            missing: "missing";
             commit: "commit";
             other: "other";
-            missing: "missing";
         }>;
         cleanliness: z.ZodEnum<{
             unknown: "unknown";
@@ -5543,9 +5763,9 @@ declare const NativeWslProjectionInventoryObservation_v1: z.ZodUnion<readonly [z
             source_head_sha: z.ZodString;
             requested_object_sha: z.ZodString;
             requested_object_type: z.ZodEnum<{
+                missing: "missing";
                 commit: "commit";
                 other: "other";
-                missing: "missing";
             }>;
             cleanliness: z.ZodEnum<{
                 unknown: "unknown";
@@ -6843,6 +7063,715 @@ declare function orderAgentWorkPreparationSteps(preparation: Preparation): Prepa
 /** Executes only the explicit preparation phase and emits hashes, never command logs. */
 declare function executeAgentWorkPreparation(input: ExecuteAgentWorkPreparationInput): Promise<AgentWorkPreparationResult>;
 
+declare const ATTEMPT_AWAITABLE_CONTRACT_VERSION: "1.0.0";
+declare const AXF_AWAITABLE_SCHEMA_VERSION: "axf/awaitable/v1";
+declare const AXF_AWAIT_RESULT_SCHEMA_VERSION: "axf/await-result/v1";
+declare const MIN_ATTEMPT_AWAITABLE_DURATION_MS = 1000;
+declare const MAX_ATTEMPT_AWAITABLE_DURATION_MS: number;
+/** Credential-free AXF observation identity. Kind-specific semantics remain AXF-owned. */
+declare const ExternalAwaitableDescriptor_v1: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axf/awaitable/v1">;
+    kind: z.ZodLiteral<"github.required-checks">;
+    subject: z.ZodObject<{
+        repository: z.ZodString;
+        headSha: z.ZodString;
+        pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    condition: z.ZodObject<{
+        type: z.ZodLiteral<"all-required-checks-terminal">;
+        requiredChecks: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                status: "status";
+                "check-run": "check-run";
+            }>;
+            name: z.ZodString;
+            appSlug: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type ExternalAwaitableDescriptor_v1 = z.infer<typeof ExternalAwaitableDescriptor_v1>;
+declare const ExternalAwaitOutcome_v1: z.ZodEnum<{
+    cancelled: "cancelled";
+    satisfied: "satisfied";
+    "terminal-failed": "terminal-failed";
+    deadline: "deadline";
+    "subject-drift": "subject-drift";
+    "observation-error": "observation-error";
+}>;
+type ExternalAwaitOutcome_v1 = z.infer<typeof ExternalAwaitOutcome_v1>;
+/** Exact normalized terminal projection returned by AXF's process-bound wait capability. */
+declare const AxfExternalAwaitResult_v1: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"axf/await-result/v1">;
+    provider: z.ZodLiteral<"github.required-checks">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        satisfied: "satisfied";
+        "terminal-failed": "terminal-failed";
+        deadline: "deadline";
+        "subject-drift": "subject-drift";
+        "observation-error": "observation-error";
+    }>;
+    terminal: z.ZodLiteral<true>;
+    durability: z.ZodLiteral<"process-bound">;
+    authorityModel: z.ZodLiteral<"host-provided">;
+    underlyingCancellation: z.ZodLiteral<false>;
+    effectiveDeadlineMs: z.ZodNumber;
+    observationCount: z.ZodNumber;
+    evidence: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
+        repository: z.ZodString;
+        headSha: z.ZodString;
+        pullRequestNumber: z.ZodNullable<z.ZodNumber>;
+        requiredChecks: z.ZodArray<z.ZodObject<{
+            source: z.ZodEnum<{
+                status: "status";
+                "check-run": "check-run";
+            }>;
+            name: z.ZodString;
+            appSlug: z.ZodNullable<z.ZodString>;
+            state: z.ZodEnum<{
+                error: "error";
+                success: "success";
+                failure: "failure";
+                completed: "completed";
+                pending: "pending";
+                missing: "missing";
+                queued: "queued";
+                in_progress: "in_progress";
+                waiting: "waiting";
+                requested: "requested";
+            }>;
+            conclusion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                success: "success";
+                failure: "failure";
+                skipped: "skipped";
+                stale: "stale";
+                neutral: "neutral";
+                cancelled: "cancelled";
+                timed_out: "timed_out";
+                action_required: "action_required";
+                startup_failure: "startup_failure";
+            }>>>;
+            terminal: z.ZodBoolean;
+            successful: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        repository: z.ZodString;
+        pullRequestNumber: z.ZodNumber;
+        expectedHeadSha: z.ZodString;
+        observedHeadSha: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+type AxfExternalAwaitResult_v1 = z.infer<typeof AxfExternalAwaitResult_v1>;
+declare const AttemptAwaitableStatus_v1: z.ZodEnum<{
+    cancelled: "cancelled";
+    registered: "registered";
+    satisfied: "satisfied";
+    deadline: "deadline";
+    observing: "observing";
+    terminal_failed: "terminal_failed";
+    subject_drift: "subject_drift";
+    observation_error: "observation_error";
+}>;
+type AttemptAwaitableStatus_v1 = z.infer<typeof AttemptAwaitableStatus_v1>;
+declare const AttemptAwaitableObserverLease_v1: z.ZodObject<{
+    observer_id: z.ZodString;
+    lease_id: z.ZodString;
+    fencing_token: z.ZodNumber;
+    acquired_at: z.ZodString;
+    expires_at: z.ZodString;
+}, z.core.$strict>;
+type AttemptAwaitableObserverLease_v1 = z.infer<typeof AttemptAwaitableObserverLease_v1>;
+declare const AttemptAwaitableTerminalResult_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    provider: z.ZodLiteral<"github.required-checks">;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        satisfied: "satisfied";
+        "terminal-failed": "terminal-failed";
+        deadline: "deadline";
+        "subject-drift": "subject-drift";
+        "observation-error": "observation-error";
+    }>;
+    source: z.ZodEnum<{
+        lexrunner: "lexrunner";
+        observer: "observer";
+    }>;
+    observed_at: z.ZodString;
+    observer_result: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axf/await-result/v1">;
+        provider: z.ZodLiteral<"github.required-checks">;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            satisfied: "satisfied";
+            "terminal-failed": "terminal-failed";
+            deadline: "deadline";
+            "subject-drift": "subject-drift";
+            "observation-error": "observation-error";
+        }>;
+        terminal: z.ZodLiteral<true>;
+        durability: z.ZodLiteral<"process-bound">;
+        authorityModel: z.ZodLiteral<"host-provided">;
+        underlyingCancellation: z.ZodLiteral<false>;
+        effectiveDeadlineMs: z.ZodNumber;
+        observationCount: z.ZodNumber;
+        evidence: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
+            repository: z.ZodString;
+            headSha: z.ZodString;
+            pullRequestNumber: z.ZodNullable<z.ZodNumber>;
+            requiredChecks: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    status: "status";
+                    "check-run": "check-run";
+                }>;
+                name: z.ZodString;
+                appSlug: z.ZodNullable<z.ZodString>;
+                state: z.ZodEnum<{
+                    error: "error";
+                    success: "success";
+                    failure: "failure";
+                    completed: "completed";
+                    pending: "pending";
+                    missing: "missing";
+                    queued: "queued";
+                    in_progress: "in_progress";
+                    waiting: "waiting";
+                    requested: "requested";
+                }>;
+                conclusion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    success: "success";
+                    failure: "failure";
+                    skipped: "skipped";
+                    stale: "stale";
+                    neutral: "neutral";
+                    cancelled: "cancelled";
+                    timed_out: "timed_out";
+                    action_required: "action_required";
+                    startup_failure: "startup_failure";
+                }>>>;
+                terminal: z.ZodBoolean;
+                successful: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            repository: z.ZodString;
+            pullRequestNumber: z.ZodNumber;
+            expectedHeadSha: z.ZodString;
+            observedHeadSha: z.ZodString;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    reason_code: z.ZodOptional<z.ZodEnum<{
+        deadline_elapsed: "deadline_elapsed";
+        operator_cancelled: "operator_cancelled";
+    }>>;
+}, z.core.$strict>;
+type AttemptAwaitableTerminalResult_v1 = z.infer<typeof AttemptAwaitableTerminalResult_v1>;
+declare const AttemptAwaitableDelivery_v1: z.ZodObject<{
+    delivery_id: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        delivered: "delivered";
+    }>;
+    completion_hash: z.ZodString;
+    attempt_count: z.ZodNumber;
+    last_attempt_at: z.ZodOptional<z.ZodString>;
+    delivered_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AttemptAwaitableDelivery_v1 = z.infer<typeof AttemptAwaitableDelivery_v1>;
+declare const AttemptAwaitableRecord_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    awaitable_id: z.ZodString;
+    attempt_id: z.ZodString;
+    worker_session_id: z.ZodOptional<z.ZodString>;
+    revision: z.ZodNumber;
+    descriptor: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"axf/awaitable/v1">;
+        kind: z.ZodLiteral<"github.required-checks">;
+        subject: z.ZodObject<{
+            repository: z.ZodString;
+            headSha: z.ZodString;
+            pullRequestNumber: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        condition: z.ZodObject<{
+            type: z.ZodLiteral<"all-required-checks-terminal">;
+            requiredChecks: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    status: "status";
+                    "check-run": "check-run";
+                }>;
+                name: z.ZodString;
+                appSlug: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    descriptor_hash: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        registered: "registered";
+        satisfied: "satisfied";
+        deadline: "deadline";
+        observing: "observing";
+        terminal_failed: "terminal_failed";
+        subject_drift: "subject_drift";
+        observation_error: "observation_error";
+    }>;
+    deadline_at: z.ZodString;
+    observer_fencing_token: z.ZodNumber;
+    observer_lease: z.ZodOptional<z.ZodObject<{
+        observer_id: z.ZodString;
+        lease_id: z.ZodString;
+        fencing_token: z.ZodNumber;
+        acquired_at: z.ZodString;
+        expires_at: z.ZodString;
+    }, z.core.$strict>>;
+    result: z.ZodOptional<z.ZodObject<{
+        schema_version: z.ZodLiteral<"1.0.0">;
+        provider: z.ZodLiteral<"github.required-checks">;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            satisfied: "satisfied";
+            "terminal-failed": "terminal-failed";
+            deadline: "deadline";
+            "subject-drift": "subject-drift";
+            "observation-error": "observation-error";
+        }>;
+        source: z.ZodEnum<{
+            lexrunner: "lexrunner";
+            observer: "observer";
+        }>;
+        observed_at: z.ZodString;
+        observer_result: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"axf/await-result/v1">;
+            provider: z.ZodLiteral<"github.required-checks">;
+            outcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                satisfied: "satisfied";
+                "terminal-failed": "terminal-failed";
+                deadline: "deadline";
+                "subject-drift": "subject-drift";
+                "observation-error": "observation-error";
+            }>;
+            terminal: z.ZodLiteral<true>;
+            durability: z.ZodLiteral<"process-bound">;
+            authorityModel: z.ZodLiteral<"host-provided">;
+            underlyingCancellation: z.ZodLiteral<false>;
+            effectiveDeadlineMs: z.ZodNumber;
+            observationCount: z.ZodNumber;
+            evidence: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
+                repository: z.ZodString;
+                headSha: z.ZodString;
+                pullRequestNumber: z.ZodNullable<z.ZodNumber>;
+                requiredChecks: z.ZodArray<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        status: "status";
+                        "check-run": "check-run";
+                    }>;
+                    name: z.ZodString;
+                    appSlug: z.ZodNullable<z.ZodString>;
+                    state: z.ZodEnum<{
+                        error: "error";
+                        success: "success";
+                        failure: "failure";
+                        completed: "completed";
+                        pending: "pending";
+                        missing: "missing";
+                        queued: "queued";
+                        in_progress: "in_progress";
+                        waiting: "waiting";
+                        requested: "requested";
+                    }>;
+                    conclusion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                        success: "success";
+                        failure: "failure";
+                        skipped: "skipped";
+                        stale: "stale";
+                        neutral: "neutral";
+                        cancelled: "cancelled";
+                        timed_out: "timed_out";
+                        action_required: "action_required";
+                        startup_failure: "startup_failure";
+                    }>>>;
+                    terminal: z.ZodBoolean;
+                    successful: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                repository: z.ZodString;
+                pullRequestNumber: z.ZodNumber;
+                expectedHeadSha: z.ZodString;
+                observedHeadSha: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+        reason_code: z.ZodOptional<z.ZodEnum<{
+            deadline_elapsed: "deadline_elapsed";
+            operator_cancelled: "operator_cancelled";
+        }>>;
+    }, z.core.$strict>>;
+    result_hash: z.ZodOptional<z.ZodString>;
+    delivery: z.ZodOptional<z.ZodObject<{
+        delivery_id: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            delivered: "delivered";
+        }>;
+        completion_hash: z.ZodString;
+        attempt_count: z.ZodNumber;
+        last_attempt_at: z.ZodOptional<z.ZodString>;
+        delivered_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    terminal_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AttemptAwaitableRecord_v1 = z.infer<typeof AttemptAwaitableRecord_v1>;
+declare const AttemptAwaitableCompletion_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    delivery_id: z.ZodString;
+    awaitable_id: z.ZodString;
+    attempt_id: z.ZodString;
+    worker_session_id: z.ZodOptional<z.ZodString>;
+    descriptor_hash: z.ZodString;
+    result: z.ZodObject<{
+        schema_version: z.ZodLiteral<"1.0.0">;
+        provider: z.ZodLiteral<"github.required-checks">;
+        outcome: z.ZodEnum<{
+            cancelled: "cancelled";
+            satisfied: "satisfied";
+            "terminal-failed": "terminal-failed";
+            deadline: "deadline";
+            "subject-drift": "subject-drift";
+            "observation-error": "observation-error";
+        }>;
+        source: z.ZodEnum<{
+            lexrunner: "lexrunner";
+            observer: "observer";
+        }>;
+        observed_at: z.ZodString;
+        observer_result: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"axf/await-result/v1">;
+            provider: z.ZodLiteral<"github.required-checks">;
+            outcome: z.ZodEnum<{
+                cancelled: "cancelled";
+                satisfied: "satisfied";
+                "terminal-failed": "terminal-failed";
+                deadline: "deadline";
+                "subject-drift": "subject-drift";
+                "observation-error": "observation-error";
+            }>;
+            terminal: z.ZodLiteral<true>;
+            durability: z.ZodLiteral<"process-bound">;
+            authorityModel: z.ZodLiteral<"host-provided">;
+            underlyingCancellation: z.ZodLiteral<false>;
+            effectiveDeadlineMs: z.ZodNumber;
+            observationCount: z.ZodNumber;
+            evidence: z.ZodUnion<readonly [z.ZodNull, z.ZodObject<{
+                repository: z.ZodString;
+                headSha: z.ZodString;
+                pullRequestNumber: z.ZodNullable<z.ZodNumber>;
+                requiredChecks: z.ZodArray<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        status: "status";
+                        "check-run": "check-run";
+                    }>;
+                    name: z.ZodString;
+                    appSlug: z.ZodNullable<z.ZodString>;
+                    state: z.ZodEnum<{
+                        error: "error";
+                        success: "success";
+                        failure: "failure";
+                        completed: "completed";
+                        pending: "pending";
+                        missing: "missing";
+                        queued: "queued";
+                        in_progress: "in_progress";
+                        waiting: "waiting";
+                        requested: "requested";
+                    }>;
+                    conclusion: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                        success: "success";
+                        failure: "failure";
+                        skipped: "skipped";
+                        stale: "stale";
+                        neutral: "neutral";
+                        cancelled: "cancelled";
+                        timed_out: "timed_out";
+                        action_required: "action_required";
+                        startup_failure: "startup_failure";
+                    }>>>;
+                    terminal: z.ZodBoolean;
+                    successful: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                repository: z.ZodString;
+                pullRequestNumber: z.ZodNumber;
+                expectedHeadSha: z.ZodString;
+                observedHeadSha: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+        reason_code: z.ZodOptional<z.ZodEnum<{
+            deadline_elapsed: "deadline_elapsed";
+            operator_cancelled: "operator_cancelled";
+        }>>;
+    }, z.core.$strict>;
+    result_hash: z.ZodString;
+    terminal_at: z.ZodString;
+}, z.core.$strict>;
+type AttemptAwaitableCompletion_v1 = z.infer<typeof AttemptAwaitableCompletion_v1>;
+declare function completionForAttemptAwaitable(record: Pick<AttemptAwaitableRecord_v1, "awaitable_id" | "attempt_id" | "worker_session_id" | "descriptor_hash" | "result" | "result_hash" | "terminal_at" | "delivery">): AttemptAwaitableCompletion_v1;
+declare function statusForAwaitableOutcome(outcome: ExternalAwaitOutcome_v1): AttemptAwaitableStatus_v1;
+declare function deliveryIdForAttemptAwaitable(awaitableId: string): string;
+declare function parseExternalAwaitableDescriptor(value: unknown): ExternalAwaitableDescriptor_v1;
+declare function containsAttemptAwaitableCredentialValue(value: string): boolean;
+
+declare const AttemptAwaitableEventType_v1: z.ZodEnum<{
+    awaitable_registered: "awaitable_registered";
+    awaitable_observation_claimed: "awaitable_observation_claimed";
+    awaitable_observation_released: "awaitable_observation_released";
+    awaitable_terminal_recorded: "awaitable_terminal_recorded";
+    awaitable_delivery_attempted: "awaitable_delivery_attempted";
+    awaitable_delivery_acknowledged: "awaitable_delivery_acknowledged";
+}>;
+type AttemptAwaitableEventType_v1 = z.infer<typeof AttemptAwaitableEventType_v1>;
+declare const AttemptAwaitableEvent_v1: z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    awaitable_id: z.ZodString;
+    attempt_id: z.ZodString;
+    sequence: z.ZodNumber;
+    awaitable_revision: z.ZodNumber;
+    mutation_id: z.ZodString;
+    mutation_fingerprint: z.ZodString;
+    type: z.ZodEnum<{
+        awaitable_registered: "awaitable_registered";
+        awaitable_observation_claimed: "awaitable_observation_claimed";
+        awaitable_observation_released: "awaitable_observation_released";
+        awaitable_terminal_recorded: "awaitable_terminal_recorded";
+        awaitable_delivery_attempted: "awaitable_delivery_attempted";
+        awaitable_delivery_acknowledged: "awaitable_delivery_acknowledged";
+    }>;
+    payload: z.ZodCustom<JsonValue, JsonValue>;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+type AttemptAwaitableEvent_v1 = z.infer<typeof AttemptAwaitableEvent_v1>;
+interface AttemptAwaitableLeaseCredential {
+    observerId: string;
+    leaseId: string;
+    fencingToken: number;
+}
+interface RegisterAttemptAwaitableInput {
+    awaitableId: string;
+    attemptId: string;
+    workerSessionId?: string;
+    descriptor: ExternalAwaitableDescriptor_v1;
+    deadlineAt: string;
+    mutationId: string;
+    now: string;
+}
+interface ClaimAttemptAwaitableObservationInput {
+    awaitableId: string;
+    expectedRevision: number;
+    observerId: string;
+    leaseId: string;
+    ttlMs: number;
+    mutationId: string;
+    now: string;
+}
+interface ReleaseAttemptAwaitableObservationInput {
+    awaitableId: string;
+    expectedRevision: number;
+    lease: AttemptAwaitableLeaseCredential;
+    mutationId: string;
+    now: string;
+}
+interface CompleteAttemptAwaitableInput {
+    awaitableId: string;
+    expectedRevision: number;
+    lease: AttemptAwaitableLeaseCredential;
+    result: AttemptAwaitableTerminalResult_v1;
+    mutationId: string;
+    now: string;
+}
+interface CancelAttemptAwaitableInput {
+    awaitableId: string;
+    expectedRevision: number;
+    mutationId: string;
+    now: string;
+}
+interface BeginAttemptAwaitableDeliveryInput {
+    awaitableId: string;
+    expectedRevision: number;
+    mutationId: string;
+    now: string;
+}
+interface AcknowledgeAttemptAwaitableDeliveryInput {
+    awaitableId: string;
+    expectedRevision: number;
+    deliveryId: string;
+    completionHash: string;
+    mutationId: string;
+    now: string;
+}
+type AttemptAwaitableMutationFailureReason = "not_found" | "attempt_not_live" | "target_mismatch" | "awaitable_conflict" | "mutation_conflict" | "stale_revision" | "held_by_other" | "lease_mismatch" | "terminal_latched" | "not_observing" | "not_terminal" | "delivery_conflict";
+type RegisterAttemptAwaitableResult = {
+    registered: true;
+    record: AttemptAwaitableRecord_v1;
+    idempotentReplay: boolean;
+} | {
+    registered: false;
+    reason: AttemptAwaitableMutationFailureReason;
+};
+type ClaimAttemptAwaitableObservationResult = {
+    claimed: true;
+    record: AttemptAwaitableRecord_v1;
+    lease: AttemptAwaitableObserverLease_v1;
+    idempotentReplay: boolean;
+} | {
+    claimed: false;
+    reason: AttemptAwaitableMutationFailureReason;
+    record?: AttemptAwaitableRecord_v1;
+};
+type MutateAttemptAwaitableResult = {
+    updated: true;
+    record: AttemptAwaitableRecord_v1;
+    idempotentReplay: boolean;
+} | {
+    updated: false;
+    reason: AttemptAwaitableMutationFailureReason;
+    record?: AttemptAwaitableRecord_v1;
+};
+interface AttemptAwaitableStore {
+    registerAttemptAwaitable(input: RegisterAttemptAwaitableInput): Promise<RegisterAttemptAwaitableResult>;
+    claimAttemptAwaitableObservation(input: ClaimAttemptAwaitableObservationInput): Promise<ClaimAttemptAwaitableObservationResult>;
+    releaseAttemptAwaitableObservation(input: ReleaseAttemptAwaitableObservationInput): Promise<MutateAttemptAwaitableResult>;
+    completeAttemptAwaitable(input: CompleteAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    cancelAttemptAwaitable(input: CancelAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    beginAttemptAwaitableDelivery(input: BeginAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    acknowledgeAttemptAwaitableDelivery(input: AcknowledgeAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    getAttemptAwaitable(awaitableId: string): Promise<AttemptAwaitableRecord_v1 | null>;
+    listRecoverableAttemptAwaitables(now: string): Promise<AttemptAwaitableRecord_v1[]>;
+    listPendingAttemptAwaitableDeliveries(): Promise<AttemptAwaitableRecord_v1[]>;
+    listAttemptAwaitableEvents(awaitableId: string): Promise<AttemptAwaitableEvent_v1[]>;
+}
+declare function parseAttemptAwaitableRecord(value: unknown): AttemptAwaitableRecord_v1;
+declare function parseAttemptAwaitableDescriptor(value: unknown): ExternalAwaitableDescriptor_v1;
+declare function parseAttemptAwaitableTerminalResult(value: unknown): AttemptAwaitableTerminalResult_v1;
+
+interface AttemptAwaitableObservationRequest {
+    descriptor: ExternalAwaitableDescriptor_v1;
+    deadlineMs: number;
+    signal: AbortSignal;
+}
+/** AXF-facing port. Authority is supplied by this host adapter, never by the durable descriptor. */
+interface AttemptAwaitableObserver {
+    observe(request: AttemptAwaitableObservationRequest): Promise<AxfExternalAwaitResult_v1>;
+}
+/**
+ * Provider-neutral continuation port. Implementations may enqueue a session message, notify a
+ * coordinator, or persist another outbox entry. They must deduplicate by completion.delivery_id.
+ */
+interface AttemptAwaitableNotifier {
+    deliver(completion: AttemptAwaitableCompletion_v1): Promise<void>;
+}
+type AttemptAwaitableSupervisorNotice = {
+    type: "observation_started";
+    awaitableId: string;
+} | {
+    type: "observation_released";
+    awaitableId: string;
+    reason: string;
+} | {
+    type: "terminal_recorded";
+    awaitableId: string;
+    outcome: string;
+} | {
+    type: "delivery_succeeded";
+    awaitableId: string;
+    deliveryId: string;
+} | {
+    type: "operation_failed";
+    awaitableId: string;
+    operation: "observe" | "release" | "deliver";
+    message: string;
+};
+interface AttemptAwaitableSupervisorOptions {
+    observerId: string;
+    now?: () => string;
+    leaseGraceMs?: number;
+    createLeaseId?: (awaitableId: string) => string;
+    deliveryRetryInitialMs?: number;
+    deliveryRetryMaxMs?: number;
+    onNotice?: (notice: AttemptAwaitableSupervisorNotice) => void | Promise<void>;
+}
+interface RegisterDurableAttemptAwaitableInput {
+    awaitableId: string;
+    attemptId: string;
+    workerSessionId?: string;
+    descriptor: ExternalAwaitableDescriptor_v1;
+    deadlineMs: number;
+    mutationId: string;
+}
+interface RegisterDurableAttemptAwaitableResult {
+    registration: RegisterAttemptAwaitableResult;
+    attachment?: AttemptAwaitableAttachmentResult;
+}
+type AttemptAwaitableAttachmentResult = "attached" | "delivery_attached" | "already_attached" | "held_by_other" | "not_found" | "not_recoverable";
+/**
+ * Durable registration, restart recovery, and at-least-once completion delivery for Attempt-bound
+ * external awaitables. Recovery performs one inventory read; live waiting happens inside AXF and
+ * notification is event-driven. This supervisor never polls from the model or from LexRunner.
+ */
+declare class AttemptAwaitableSupervisor {
+    private readonly store;
+    private readonly observer;
+    private readonly notifier;
+    private readonly options;
+    private readonly observations;
+    private readonly deliveries;
+    private readonly leaseExpiryWakeups;
+    private readonly now;
+    private readonly leaseGraceMs;
+    private readonly createLeaseId;
+    private readonly deliveryRetryInitialMs;
+    private readonly deliveryRetryMaxMs;
+    private stopping;
+    constructor(store: AttemptAwaitableStore, observer: AttemptAwaitableObserver, notifier: AttemptAwaitableNotifier, options: AttemptAwaitableSupervisorOptions);
+    register(input: RegisterDurableAttemptAwaitableInput): Promise<RegisterDurableAttemptAwaitableResult>;
+    recover(): Promise<{
+        observations: string[];
+        deliveries: string[];
+        heldByOther: string[];
+    }>;
+    attach(awaitableId: string): Promise<AttemptAwaitableAttachmentResult>;
+    cancel(awaitableId: string, mutationId: string): Promise<MutateAttemptAwaitableResult>;
+    get(awaitableId: string): Promise<AttemptAwaitableRecord_v1 | null>;
+    wait(awaitableId: string): Promise<void>;
+    shutdown(): Promise<void>;
+    private runObservation;
+    private recordLexRunnerDeadline;
+    private complete;
+    private release;
+    private attachDelivery;
+    private scheduleLeaseExpiryWakeup;
+    private clearLeaseExpiryWakeup;
+    private runDelivery;
+    private retryDelay;
+    private notice;
+}
+
+interface AxfCliAttemptAwaitableObserverOptions {
+    executable?: string;
+    executableArgs?: readonly string[];
+    capabilityId?: "global.wait.external" | "global.await.external";
+    cwd?: string;
+    /** Resolve authority at observation time. The returned values are never persisted by LexRunner. */
+    environment?: () => NodeJS.ProcessEnv;
+}
+/** No-shell AXF CLI adapter for one bounded, process-bound external wait. */
+declare class AxfCliAttemptAwaitableObserver implements AttemptAwaitableObserver {
+    private readonly options;
+    private readonly executable;
+    private readonly executableArgs;
+    private readonly capabilityId;
+    constructor(options?: AxfCliAttemptAwaitableObserverOptions);
+    observe(request: AttemptAwaitableObservationRequest): Promise<AxfExternalAwaitResult_v1>;
+}
+
 interface AttemptReceiptStatusResult {
     receipt: AttemptReceiptStatusProjection | null;
 }
@@ -7053,6 +7982,346 @@ interface AttemptVerificationHandlerOptions {
 }
 declare function createAttemptVerificationHandlers(options?: AttemptVerificationHandlerOptions): AttemptVerificationHandlers;
 
+/** Deterministic in-memory implementation of the controller coordination contract. */
+declare class InMemoryCoordinationStore implements CoordinationStore {
+    private readonly records;
+    private readonly events;
+    acquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewControllerLease(input: RenewControllerLeaseInput): Promise<RenewControllerLeaseResult>;
+    releaseControllerLease(input: ReleaseControllerLeaseInput): Promise<ReleaseControllerLeaseResult>;
+    getControllerLease(runId: string): Promise<ControllerLease | null>;
+    getRunCoordination(runId: string): Promise<RunCoordinationRecord | null>;
+    listRunCoordinationEvents(runId: string): Promise<RunCoordinationEvent[]>;
+    compareAndSetRunState(input: CompareAndSetRunStateInput): Promise<CompareAndSetRunStateResult>;
+    close(): Promise<void>;
+    /**
+     * Execute an in-memory mutation while the presented controller lease is
+     * authoritative. Subclasses use this synchronous critical section so a
+     * workspace mutation cannot be separated from controller authentication.
+     */
+    protected withActiveControllerCredential<T>(credential: {
+        runId: string;
+        controllerId: string;
+        leaseId: string;
+        fencingToken: number;
+    }, now: string, expectedRunRevision: number, action: () => T): {
+        authenticated: true;
+        value: T;
+    } | {
+        authenticated: false;
+        reason: "no_active_lease" | "lease_mismatch" | "stale_fence" | "lease_expired" | "stale_run_revision";
+        currentRunRevision?: number;
+    };
+    private createLease;
+    private toPublicRecord;
+}
+
+/**
+ * In-memory authoritative controller + workspace lifecycle store.
+ *
+ * Extending the coordination store is intentional: controller credential
+ * validation and each attempt/lease/event mutation share one synchronous
+ * critical section instead of becoming two independently canonical stores.
+ */
+declare class InMemoryWorkspaceLifecycleStore extends InMemoryCoordinationStore implements WorkspaceLifecycleStore, LaunchEnvelopeBindingStore, TaskPacketBindingStore, WorkerSessionStore, WorkerAuthorityDecisionStore, AttemptVerificationStore, AttemptAcceptanceStore, AgentWorkFanoutStore {
+    private readonly attempts;
+    private readonly attemptRetryDeltas;
+    private readonly fanoutPlans;
+    private readonly fanoutBindings;
+    private readonly fanInDecisions;
+    private readonly fanInDecisionByFanout;
+    private readonly fanoutMutations;
+    private readonly workspaceLeases;
+    private readonly lifecycleEvents;
+    private readonly mutations;
+    private readonly workerSessions;
+    private readonly workerAdapterBindings;
+    private readonly workerSessionByAttempt;
+    private readonly workerEvents;
+    private readonly workerMutations;
+    private readonly workerAuthorityEvents;
+    private readonly workerAuthorityMutations;
+    private readonly launchEnvelopeBindings;
+    private readonly taskPacketBindings;
+    private readonly attemptReceipts;
+    private readonly receiptByAttempt;
+    private readonly receiptByHash;
+    private readonly receiptEvents;
+    private readonly receiptMutations;
+    private readonly attemptVerifications;
+    private readonly verificationAuthorizations;
+    private readonly verificationAuthorizationByAttempt;
+    private readonly verificationByAttempt;
+    private readonly verificationByHash;
+    private readonly verificationEvents;
+    private readonly verificationMutations;
+    private readonly verificationBeginMutations;
+    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[]>;
+    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>;
+    getAttemptRetryDelta(attemptId: string): Promise<AttemptRetryDeltaRecord | null>;
+    getWorkspaceLease(leaseId: string): Promise<WorkspaceLifecycleLeaseRecord | null>;
+    listWorkspaceLeases(runId: string): Promise<WorkspaceLifecycleLeaseRecord[]>;
+    listWorkspaceLifecycleEvents(runId: string): Promise<WorkspaceLifecycleEvent[]>;
+    bindLaunchEnvelope(input: BindLaunchEnvelopeInput): Promise<LaunchEnvelopeBindingResult>;
+    getLaunchEnvelopeBinding(attemptId: string): Promise<LaunchEnvelopeBindingRecord | null>;
+    reconcileIncompleteLaunch(input: ReconcileIncompleteLaunchInput): Promise<WorkspaceMutationResult>;
+    getTaskPacketBinding(attemptId: string): Promise<TaskPacketBindingRecord | null>;
+    attachWorkerSession(input: AttachWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    heartbeatWorkerSession(input: HeartbeatWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    endWorkerSession(input: EndWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    getWorkerSession(sessionId: string): Promise<WorkerSessionRecord | null>;
+    getWorkerSessionForAttempt(attemptId: string): Promise<WorkerSessionRecord | null>;
+    getWorkerAdapterBinding(sessionId: string): Promise<WorkerAdapterBindingRecord | null>;
+    listWorkerSessionEvents(runId: string): Promise<WorkerSessionEvent[]>;
+    recordWorkerAuthorityDecision(input: RecordWorkerAuthorityDecisionInput): Promise<WorkerAuthorityDecisionResult>;
+    listWorkerAuthorityEvents(runId: string): Promise<WorkerAuthorityEventRecord[]>;
+    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[]>;
+    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>;
+    listAttemptVerificationEvents(runId: string): Promise<AttemptVerificationEvent[]>;
+    getAttemptVerificationAuthorization(verificationId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    getAttemptVerificationAuthorizationForAttempt(attemptId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    applyAttemptAcceptance(input: ApplyAttemptAcceptanceInput): Promise<WorkspaceMutationResult>;
+    private submitNewVerification;
+    private recordVerificationEvent;
+    private recordVerificationStartedEvent;
+    private verificationBeginFailure;
+    private verificationFailure;
+    private committedVerificationResult;
+    private submitNewReceipt;
+    private recordReceiptEvent;
+    private receiptFailure;
+    private committedReceiptResult;
+    private mutateWorker;
+    private validateWorkerBinding;
+    private validateSession;
+    private recordWorker;
+    private workerFailure;
+    private authorityFailure;
+    private mutate;
+    private mutateWorkspace;
+    private validateAttempt;
+    private validateRetryDelta;
+    private validateFanoutBinding;
+    private hasNonFanoutMutation;
+    private validFanInDecision;
+    private validInheritedRetryEvidence;
+    private finishLease;
+    private quarantine;
+    private record;
+    private failure;
+}
+
+type AwaitableRecord$1 = ReturnType<typeof AttemptAwaitableRecord_v1.parse>;
+declare class InMemoryAttemptAwaitableStore extends InMemoryWorkspaceLifecycleStore implements AttemptAwaitableStore {
+    private readonly awaitables;
+    private readonly awaitableEvents;
+    registerAttemptAwaitable(input: RegisterAttemptAwaitableInput): Promise<RegisterAttemptAwaitableResult>;
+    claimAttemptAwaitableObservation(input: ClaimAttemptAwaitableObservationInput): Promise<ClaimAttemptAwaitableObservationResult>;
+    releaseAttemptAwaitableObservation(input: ReleaseAttemptAwaitableObservationInput): Promise<MutateAttemptAwaitableResult>;
+    completeAttemptAwaitable(input: CompleteAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    cancelAttemptAwaitable(input: CancelAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    beginAttemptAwaitableDelivery(input: BeginAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    acknowledgeAttemptAwaitableDelivery(input: AcknowledgeAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    getAttemptAwaitable(awaitableId: string): Promise<AwaitableRecord$1 | null>;
+    listRecoverableAttemptAwaitables(nowCandidate: string): Promise<AwaitableRecord$1[]>;
+    listPendingAttemptAwaitableDeliveries(): Promise<AwaitableRecord$1[]>;
+    listAttemptAwaitableEvents(awaitableId: string): Promise<AttemptAwaitableEvent_v1[]>;
+    private mutateAwaitable;
+    private appendEvent;
+    private findMutation;
+}
+
+interface SqliteCoordinationStoreOptions {
+    readOnly?: boolean;
+}
+/** SQLite implementation with transactionally serialized lease and CAS operations. */
+declare class SqliteCoordinationStore implements CoordinationStore {
+    /** Shared connection for additive stores whose mutations must share this transaction boundary. */
+    protected readonly db: Database;
+    private closed;
+    constructor(dbPath: string, options?: SqliteCoordinationStoreOptions);
+    acquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewControllerLease(input: RenewControllerLeaseInput): Promise<RenewControllerLeaseResult>;
+    releaseControllerLease(input: ReleaseControllerLeaseInput): Promise<ReleaseControllerLeaseResult>;
+    getControllerLease(runId: string): Promise<ControllerLease | null>;
+    getRunCoordination(runId: string): Promise<RunCoordinationRecord | null>;
+    listRunCoordinationEvents(runId: string): Promise<RunCoordinationEvent[]>;
+    compareAndSetRunState(input: CompareAndSetRunStateInput): Promise<CompareAndSetRunStateResult>;
+    close(): Promise<void>;
+    protected immediateTransaction<T>(fn: () => T): T;
+    private applyCoordinationMigration;
+    private selectRow;
+    private requireRow;
+    private selectEvent;
+    private requireEvent;
+    private createLease;
+    private rowToLease;
+    private rowToRecord;
+    private rowToEvent;
+    private serializeState;
+}
+
+/** SQLite attempt/workspace store sharing the authoritative controller transaction. */
+declare class SqliteWorkspaceLifecycleStore extends SqliteCoordinationStore implements WorkspaceLifecycleStore, LaunchEnvelopeBindingStore, TaskPacketBindingStore, WorkerSessionStore, WorkerAuthorityDecisionStore, AttemptVerificationStore, AttemptAcceptanceStore, AgentWorkFanoutStore {
+    constructor(dbPath: string, options?: SqliteCoordinationStoreOptions);
+    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[]>;
+    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>;
+    getAttemptRetryDelta(attemptId: string): Promise<AttemptRetryDeltaRecord | null>;
+    getWorkspaceLease(leaseId: string): Promise<WorkspaceLifecycleLeaseRecord | null>;
+    listWorkspaceLeases(runId: string): Promise<WorkspaceLifecycleLeaseRecord[]>;
+    listWorkspaceLifecycleEvents(runId: string): Promise<WorkspaceLifecycleEvent[]>;
+    bindLaunchEnvelope(input: BindLaunchEnvelopeInput): Promise<LaunchEnvelopeBindingResult>;
+    getLaunchEnvelopeBinding(attemptId: string): Promise<LaunchEnvelopeBindingRecord | null>;
+    reconcileIncompleteLaunch(input: ReconcileIncompleteLaunchInput): Promise<WorkspaceMutationResult>;
+    getTaskPacketBinding(attemptId: string): Promise<TaskPacketBindingRecord | null>;
+    attachWorkerSession(input: AttachWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    heartbeatWorkerSession(input: HeartbeatWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    endWorkerSession(input: EndWorkerSessionInput): Promise<WorkerSessionMutationResult>;
+    getWorkerSession(sessionId: string): Promise<WorkerSessionRecord | null>;
+    getWorkerSessionForAttempt(attemptId: string): Promise<WorkerSessionRecord | null>;
+    getWorkerAdapterBinding(sessionId: string): Promise<WorkerAdapterBindingRecord | null>;
+    listWorkerSessionEvents(runId: string): Promise<WorkerSessionEvent[]>;
+    recordWorkerAuthorityDecision(input: RecordWorkerAuthorityDecisionInput): Promise<WorkerAuthorityDecisionResult>;
+    listWorkerAuthorityEvents(runId: string): Promise<WorkerAuthorityEventRecord[]>;
+    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[]>;
+    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>;
+    listAttemptVerificationEvents(runId: string): Promise<AttemptVerificationEvent[]>;
+    getAttemptVerificationAuthorization(verificationId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    getAttemptVerificationAuthorizationForAttempt(attemptId: string): Promise<AttemptVerificationAuthorizationRecord | null>;
+    applyAttemptAcceptance(input: ApplyAttemptAcceptanceInput): Promise<WorkspaceMutationResult>;
+    private submitNewVerification;
+    private recordVerificationEvent;
+    private recordVerificationStartedEvent;
+    private storeVerificationMutation;
+    private verificationFailure;
+    private verificationBeginFailure;
+    private submitNewReceipt;
+    private recordReceiptEvent;
+    private storeReceiptMutation;
+    private receiptFailure;
+    private committedReceiptResult;
+    private committedVerificationResult;
+    private mutateWorker;
+    private validateWorkerBinding;
+    private validateSession;
+    private recordWorker;
+    private workerFailure;
+    private authorityFailure;
+    private mutate;
+    private mutateWorkspace;
+    private validateAttempt;
+    private finish;
+    private quarantine;
+    private record;
+    private failure;
+    private attempt;
+    private requireAttempt;
+    private lease;
+    private requireLease;
+    private workerSession;
+    private launchEnvelopeBinding;
+    private taskPacketBinding;
+    private attemptReceipt;
+    private requireAttemptReceipt;
+    private attemptReceiptByHash;
+    private getReceiptForAttempt;
+    private attemptVerification;
+    private verificationAuthorization;
+    private requireVerificationAuthorization;
+    private verificationAuthorizationForAttempt;
+    private requireAttemptVerification;
+    private attemptVerificationByHash;
+    private getVerificationForAttempt;
+    private requireLaunchEnvelopeBinding;
+    private hasTable;
+    private requireWorkerSession;
+    private workerSessionForAttempt;
+    private workerSessionForNativeIdentity;
+    private bumpAttempt;
+    private withFanoutAuthority;
+    private fanoutPlan;
+    private fanoutBinding;
+    private fanInDecision;
+    private fanInDecisionForFanout;
+    private validateFanInDecisionRow;
+    private fanoutMutation;
+    private insertFanoutMutation;
+    private nonFanoutMutationClaim;
+    private validateFanoutBinding;
+    private validFanInDecision;
+    private validateRetryDelta;
+    private validInheritedRetryEvidence;
+    private applyWorkspaceMigration;
+}
+
+type AwaitableRecord = ReturnType<typeof AttemptAwaitableRecord_v1.parse>;
+declare class SqliteAttemptAwaitableStore extends SqliteWorkspaceLifecycleStore implements AttemptAwaitableStore {
+    constructor(dbPath: string, options?: SqliteCoordinationStoreOptions);
+    registerAttemptAwaitable(input: RegisterAttemptAwaitableInput): Promise<RegisterAttemptAwaitableResult>;
+    claimAttemptAwaitableObservation(input: ClaimAttemptAwaitableObservationInput): Promise<ClaimAttemptAwaitableObservationResult>;
+    releaseAttemptAwaitableObservation(input: ReleaseAttemptAwaitableObservationInput): Promise<MutateAttemptAwaitableResult>;
+    completeAttemptAwaitable(input: CompleteAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    cancelAttemptAwaitable(input: CancelAttemptAwaitableInput): Promise<MutateAttemptAwaitableResult>;
+    beginAttemptAwaitableDelivery(input: BeginAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    acknowledgeAttemptAwaitableDelivery(input: AcknowledgeAttemptAwaitableDeliveryInput): Promise<MutateAttemptAwaitableResult>;
+    getAttemptAwaitable(awaitableId: string): Promise<AwaitableRecord | null>;
+    listRecoverableAttemptAwaitables(nowCandidate: string): Promise<AwaitableRecord[]>;
+    listPendingAttemptAwaitableDeliveries(): Promise<AwaitableRecord[]>;
+    listAttemptAwaitableEvents(awaitableId: string): Promise<AttemptAwaitableEvent_v1[]>;
+    private mutateAwaitable;
+    private insertAwaitable;
+    private updateAwaitable;
+    private insertEvent;
+    private awaitable;
+    private requireAwaitable;
+    private eventByMutation;
+    private applyAwaitableMigration;
+}
+
 /**
  * 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
@@ -7850,7 +9119,7 @@ interface BoundedGateRunResult {
         gates: Array<{
             name: string;
             status: string;
-            failureKind?: "nonzero_exit" | "spawn_error" | "timeout";
+            failureKind?: "nonzero_exit" | "spawn_error" | "timeout" | "evidence_error";
             timeoutCleanup?: {
                 method: "process-group" | "taskkill" | "direct-child";
                 forceKilled: boolean;
@@ -8501,4 +9770,4 @@ declare function createWorkflowGuide(phase: WorkflowPhase): WorkflowGuide;
 declare function inspectRegisteredCliSurface(): RegisteredCliCommand[];
 declare function main(argv?: string[]): Promise<void>;
 
-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 AgentExecutionPathBindingContext, type AgentExecutionPathBindingValidation, AgentExecutionPathMapping_v1, type AgentTaskPacketHashInput, AgentTaskPacketHashInput_v1, AgentTaskPacket_v1, type AgentTaskReceiptBindingContext, AgentTaskReceiptOutcome, type AgentTaskReceiptV2BindingContext, AgentTaskReceipt_v1, AgentTaskReceipt_v2, AgentWorkContainmentPreflightRequestJsonSchema, 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, NATIVE_WSL_PROJECTION_CONTRACT_VERSION, NATIVE_WSL_PROJECTION_HASH_PROFILE, NativeDirectoryIdentityClaim_v1, NativeExecutionPathMapping_v1, NativeWslExecutionPathMapping_v1, NativeWslProjectionCleanupRequestJsonSchema, NativeWslProjectionInventoryObservation_v1, NativeWslProjectionInventoryState, NativeWslProjectionManifest_v1, NativeWslProjectionNextAction, NativeWslProjectionOutcome, NativeWslProjectionPathMapping_v1, NativeWslProjectionPlanAction, NativeWslProjectionPlanReason, NativeWslProjectionPlan_v1, NativeWslProjectionPrepareRequestJsonSchema, NativeWslProjectionQuarantineRequestJsonSchema, NativeWslProjectionReasonCode, NativeWslProjectionReceipt_v1, NativeWslProjectionRequestJsonSchema, NativeWslProjectionRequest_v1, NativeWslProjectionSelection_v1, NativeWslProjectionStatusRequestJsonSchema, NativeWslSourceObservation_v1, type PlanArtifactFailureCode, type PlanArtifactIdentity, PlanArtifactService, PlanArtifactServiceError, type PlanArtifactSource, PlanCreationService, type RepoTarget, type ResolvePlanArtifactInput, type ResolvedPlanArtifact, 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, asPlanValidationFailure, attemptStatusRequiresReceipt, attemptStatusRequiresVerification, bootstrapWorkspace, canonicalJSONStringify, computeAgentEngineVerificationV2Hash, computeAgentTaskPacketHash, computeFanInEvidenceSetHash, computeMergeOrder, createAgentTaskPacket, createAgentWorkContainmentPreflightHandler, createAttemptLifecycleHandlers, createAttemptReceiptHandlers, createAttemptVerificationHandlers, createAttemptWorkerHandlers, createFileAnalyzer, createGitHubAPI, createGitHubClient, createGitOperations, createNativeExecutionPathMapping, createNativeWslExecutionPathMapping, createNativeWslProjectionLifecycleHandlers, createNativeWslProjectionManifest, createNativeWslProjectionPathMapping, createNativeWslProjectionReceipt, createNativeWslProjectionRequest, createNativeWslProjectionSelection, createNativeWslSourceObservation, createRunManager, createWorkflowGuide, detectProjectType, executeAgentWorkPreparation, executeGatesWithPolicy, formatPlanValidationFailure, formatPlanValidationFailureText, generateGitHubSnapshot, generateMultiRepoPlan, generatePlan, generatePlanFromGitHub, generateSnapshot, getEnvironmentSuggestions, healthChecker, initLocalOverlay, inspectRegisteredCliSurface, isTerminalAttemptStatus, loadInputs, loadPlan, main, nativeWslProjectionId, orderAgentWorkPreparationSteps, parseAgentEngineVerification, parseAgentEngineVerificationV2, parseAgentTaskPacket, parseAgentTaskReceipt, parseAgentTaskReceiptV2, parseAttempt, parseControllerLease, parseExecutionEnvelope, parseHumanActionReceipt, parseHumanActionRequest, parseRun, parseWorkItem, parseWorkerSession, parseWorkspaceAllocation, parseWorkspaceLease, planNativeWslProjection, resolveProfile, validateAgentEngineVerificationV2PacketReferences, validateAgentExecutionPathBinding, validateAgentTaskReceiptBinding, validateAgentTaskReceiptV2Binding, validateAgentTaskReceiptV2PacketReferences, validateHumanActionReceiptBinding, writeGateImpactReceipt };
+export { AGENT_ENGINE_VERIFICATION_V2_VERSION, AGENT_TASK_RECEIPT_PATCH_PROFILE, AGENT_TASK_RECEIPT_V2_VERSION, AGENT_WORK_CONTRACT_VERSION, ATTEMPT_AWAITABLE_CONTRACT_VERSION, AXF_AWAITABLE_SCHEMA_VERSION, AXF_AWAIT_RESULT_SCHEMA_VERSION, type AcknowledgeAttemptAwaitableDeliveryInput, AgentEngineVerification_v1, AgentEngineVerification_v2, type AgentExecutionPathBindingContext, type AgentExecutionPathBindingValidation, AgentExecutionPathMapping_v1, type AgentTaskPacketHashInput, AgentTaskPacketHashInput_v1, AgentTaskPacket_v1, type AgentTaskReceiptBindingContext, AgentTaskReceiptOutcome, type AgentTaskReceiptV2BindingContext, AgentTaskReceipt_v1, AgentTaskReceipt_v2, AgentWorkContainmentPreflightRequestJsonSchema, AgentWorkFanInDecision_v1, type AgentWorkFanInResult, AgentWorkFanoutPlan_v1, AgentWorkFanoutService, type AgentWorkPreparationCommandResult, type AgentWorkPreparationCommandRunner, AgentWorkPreparationReceipt_v1, type AgentWorkPreparationResult, AttemptAcceptanceApplyRequestJsonSchema, AttemptAcceptanceStatusRequestJsonSchema, type AttemptAwaitableAttachmentResult, AttemptAwaitableCompletion_v1, AttemptAwaitableDelivery_v1, AttemptAwaitableEventType_v1, AttemptAwaitableEvent_v1, type AttemptAwaitableLeaseCredential, type AttemptAwaitableMutationFailureReason, type AttemptAwaitableNotifier, type AttemptAwaitableObservationRequest, type AttemptAwaitableObserver, AttemptAwaitableObserverLease_v1, AttemptAwaitableRecord_v1, AttemptAwaitableStatus_v1, type AttemptAwaitableStore, AttemptAwaitableSupervisor, type AttemptAwaitableSupervisorNotice, type AttemptAwaitableSupervisorOptions, AttemptAwaitableTerminalResult_v1, AttemptPrepareRequestJsonSchema, AttemptReceiptStatusRequestJsonSchema, AttemptReceiptSubmitRequestJsonSchema, AttemptRetryDeltaDimension_v1, AttemptRetryDelta_v1, AttemptStartRequestJsonSchema, AttemptStatus, AttemptStatusInputJsonSchema, AttemptVerificationRunRequestJsonSchema, AttemptVerificationStatusRequestJsonSchema, AttemptWorkerAttachRequestJsonSchema, AttemptWorkerEndRequestJsonSchema, AttemptWorkerHeartbeatRequestJsonSchema, AttemptWorkerStatusRequestJsonSchema, Attempt_v1, AuthorityEnvelope, AxfCliAttemptAwaitableObserver, type AxfCliAttemptAwaitableObserverOptions, AxfExternalAwaitResult_v1, type BeginAttemptAwaitableDeliveryInput, type BoundedDiscoveryResult, type BoundedGateRunResult, type BoundedIntegrationStatus, type BoundedMergeApplicationResult, type BoundedMergeOrderResult, type CancelAttemptAwaitableInput, type ClaimAttemptAwaitableObservationInput, type ClaimAttemptAwaitableObservationResult, ClaimedCheckOutcome, type CompleteAttemptAwaitableInput, ConfigurationQueryService, ControllerLease_v1, type CreateAgentWorkFanoutInput, type DecideAgentWorkFanInInput, DiscoveryQueryService, EngineVerificationCheckSource_v2, EngineVerificationDeterminism_v2, EngineVerificationTrustGapReason_v2, type ExecuteAgentWorkPreparationInput, ExecutionEnvelope_v1, ExecutionEnvironmentOS, ExecutionState, ExternalAwaitOutcome_v1, ExternalAwaitableDescriptor_v1, 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, InMemoryAttemptAwaitableStore, IntegrationQueryServiceError, IntegrationRecordCompatibilityError, IntegrationRecordCompatibilityService, IntegrationStatusQueryService, MAX_ATTEMPT_AWAITABLE_DURATION_MS, MIN_ATTEMPT_AWAITABLE_DURATION_MS, type MergeApplicationExecution, type MergeApplicationFailureCode, type MergeApplicationRuntime, MergeApplicationService, MergeApplicationServiceError, MergeEligibilityEvaluator, MergeOrderQueryService, type MultiRepoPlanOptions$1 as MultiRepoPlanOptions, type MutateAttemptAwaitableResult, NATIVE_WSL_PROJECTION_CONTRACT_VERSION, NATIVE_WSL_PROJECTION_HASH_PROFILE, NativeDirectoryIdentityClaim_v1, NativeExecutionPathMapping_v1, NativeWslExecutionPathMapping_v1, NativeWslProjectionCleanupRequestJsonSchema, NativeWslProjectionInventoryObservation_v1, NativeWslProjectionInventoryState, NativeWslProjectionManifest_v1, NativeWslProjectionNextAction, NativeWslProjectionOutcome, NativeWslProjectionPathMapping_v1, NativeWslProjectionPlanAction, NativeWslProjectionPlanReason, NativeWslProjectionPlan_v1, NativeWslProjectionPrepareRequestJsonSchema, NativeWslProjectionQuarantineRequestJsonSchema, NativeWslProjectionReasonCode, NativeWslProjectionReceipt_v1, NativeWslProjectionRequestJsonSchema, NativeWslProjectionRequest_v1, NativeWslProjectionSelection_v1, NativeWslProjectionStatusRequestJsonSchema, NativeWslSourceObservation_v1, type PlanArtifactFailureCode, type PlanArtifactIdentity, PlanArtifactService, PlanArtifactServiceError, type PlanArtifactSource, PlanCreationService, type RegisterAttemptAwaitableInput, type RegisterAttemptAwaitableResult, type RegisterDurableAttemptAwaitableInput, type RegisterDurableAttemptAwaitableResult, type ReleaseAttemptAwaitableObservationInput, type RepoTarget, type ResolvePlanArtifactInput, type ResolvedPlanArtifact, RunStatus, Run_v1, STRICT_FANOUT_SELECTION_CRITERIA, SqliteAttemptAwaitableStore, VerificationOutcome, WorkItem_v1, WorkerSessionBackend, WorkerSessionStatus, WorkerSession_v1, WorkspaceAllocationStatus, WorkspaceAllocation_v1, WorkspaceCleanupDisposition, WorkspaceConfigServiceError, WorkspaceDiagnosticsService, WorkspaceInitializationService, WorkspaceLeaseStatus, WorkspaceLease_v1, applyGateImpactSelection, asPlanValidationFailure, attemptStatusRequiresReceipt, attemptStatusRequiresVerification, bootstrapWorkspace, canonicalJSONStringify, completionForAttemptAwaitable, computeAgentEngineVerificationV2Hash, computeAgentTaskPacketHash, computeFanInEvidenceSetHash, computeMergeOrder, containsAttemptAwaitableCredentialValue, createAgentTaskPacket, createAgentWorkContainmentPreflightHandler, createAttemptLifecycleHandlers, createAttemptReceiptHandlers, createAttemptVerificationHandlers, createAttemptWorkerHandlers, createFileAnalyzer, createGitHubAPI, createGitHubClient, createGitOperations, createNativeExecutionPathMapping, createNativeWslExecutionPathMapping, createNativeWslProjectionLifecycleHandlers, createNativeWslProjectionManifest, createNativeWslProjectionPathMapping, createNativeWslProjectionReceipt, createNativeWslProjectionRequest, createNativeWslProjectionSelection, createNativeWslSourceObservation, createRunManager, createWorkflowGuide, deliveryIdForAttemptAwaitable, detectProjectType, executeAgentWorkPreparation, executeGatesWithPolicy, formatPlanValidationFailure, formatPlanValidationFailureText, generateGitHubSnapshot, generateMultiRepoPlan, generatePlan, generatePlanFromGitHub, generateSnapshot, getEnvironmentSuggestions, healthChecker, initLocalOverlay, inspectRegisteredCliSurface, isTerminalAttemptStatus, loadInputs, loadPlan, main, nativeWslProjectionId, orderAgentWorkPreparationSteps, parseAgentEngineVerification, parseAgentEngineVerificationV2, parseAgentTaskPacket, parseAgentTaskReceipt, parseAgentTaskReceiptV2, parseAttempt, parseAttemptAwaitableDescriptor, parseAttemptAwaitableRecord, parseAttemptAwaitableTerminalResult, parseControllerLease, parseExecutionEnvelope, parseExternalAwaitableDescriptor, parseHumanActionReceipt, parseHumanActionRequest, parseRun, parseWorkItem, parseWorkerSession, parseWorkspaceAllocation, parseWorkspaceLease, planNativeWslProjection, resolveProfile, statusForAwaitableOutcome, validateAgentEngineVerificationV2PacketReferences, validateAgentExecutionPathBinding, validateAgentTaskReceiptBinding, validateAgentTaskReceiptV2Binding, validateAgentTaskReceiptV2PacketReferences, validateHumanActionReceiptBinding, writeGateImpactReceipt };