@smartergpt/lexrunner 1.2.1 → 1.4.0

package/dist/cli.d.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 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-DciX_uRh.js';
+export { m as mcpToolError } from './adapters-r7_TjMwo.js';
 import { Octokit } from '@octokit/rest';
-import '@smartergpt/lex/errors';
 
 /**
  * Gate execution result
@@ -221,6 +221,56 @@ declare const Plan: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 type Plan = z.infer<typeof Plan>;
+/**
+ * Machine-readable validation error
+ */
+interface ValidationError {
+    path: string;
+    message: string;
+    code: string;
+}
+interface PlanValidationFailure {
+    contract: "bounded-ax-v1";
+    valid: false;
+    code: string;
+    message: string;
+    errorCount: number;
+    errors: ValidationError[];
+    errorsTruncated: boolean;
+    nextActions: string[];
+    context: {
+        errorCount: number;
+        errorsTruncated: boolean;
+    };
+}
+/**
+ * Schema validation error - thrown when Zod validation fails
+ * Now extends AXErrorException to provide structured error with nextActions
+ */
+declare class SchemaValidationError extends AXErrorException {
+    readonly issues: z.ZodIssue[];
+    readonly errors: ValidationError[];
+    readonly errorCount: number;
+    readonly errorsTruncated: boolean;
+    constructor(issues: z.ZodIssue[]);
+    /**
+     * Get legacy machine-readable error format for backward compatibility
+     */
+    toLegacyJSON(): {
+        valid: false;
+        errors: ValidationError[];
+    };
+}
+/**
+ * Return the stable, bounded validation envelope used by CLI and MCP surfaces.
+ *
+ * Raw Zod issues are intentionally not returned because they can contain the
+ * rejected input. The normalized error list retains only path, message, and
+ * code, with deterministic count and byte limits.
+ */
+declare function formatPlanValidationFailure(error: SchemaValidationError): PlanValidationFailure;
+declare function asPlanValidationFailure(error: unknown): PlanValidationFailure | undefined;
+declare function formatPlanValidationFailureText(failure: PlanValidationFailure): string;
 /**
  * Load and validate a plan.json file
  */
@@ -578,6 +628,10 @@ declare function executeGatesWithPolicy(plan: Plan, executionState: ExecutionSta
     runId?: string;
     baseDir?: string;
     turnCostTracker?: MergeWeaveTurnCost;
+    onlyItem?: string;
+    onlyGate?: string;
+    emitReceipt?: boolean;
+    suppressStdout?: boolean;
 }): Promise<void>;
 
 /**
@@ -1194,8 +1248,8 @@ type ArtifactType = keyof typeof ARTIFACT_TYPES;
 declare const ListArtifactsInputSchema: z.ZodObject<{
     runId: z.ZodString;
     type: z.ZodOptional<z.ZodEnum<{
-        gate: "gate";
         failure: "failure";
+        gate: "gate";
         log: "log";
         decision: "decision";
         report: "report";
@@ -1213,8 +1267,8 @@ declare const ListArtifactsOutputSchema: z.ZodObject<{
     artifacts: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         type: z.ZodEnum<{
-            gate: "gate";
             failure: "failure";
+            gate: "gate";
             log: "log";
             decision: "decision";
             report: "report";
@@ -1916,7 +1970,6 @@ declare const WorkItem_v1: z.ZodObject<{
 }, z.core.$strict>;
 type WorkItem_v1 = z.infer<typeof WorkItem_v1>;
 declare const RunStatus: z.ZodEnum<{
-    created: "created";
     blocked: "blocked";
     completed: "completed";
     planning: "planning";
@@ -1925,6 +1978,7 @@ declare const RunStatus: z.ZodEnum<{
     failed: "failed";
     paused: "paused";
     cancelled: "cancelled";
+    created: "created";
     executing: "executing";
     delivering: "delivering";
     awaiting_human: "awaiting_human";
@@ -1951,7 +2005,6 @@ declare const Run_v1: z.ZodObject<{
         release: z.ZodBoolean;
     }, z.core.$strict>;
     status: z.ZodEnum<{
-        created: "created";
         blocked: "blocked";
         completed: "completed";
         planning: "planning";
@@ -1960,6 +2013,7 @@ declare const Run_v1: z.ZodObject<{
         failed: "failed";
         paused: "paused";
         cancelled: "cancelled";
+        created: "created";
         executing: "executing";
         delivering: "delivering";
         awaiting_human: "awaiting_human";
@@ -1986,15 +2040,15 @@ declare const AttemptStatus: z.ZodEnum<{
     failed: "failed";
     cancelled: "cancelled";
     prepared: "prepared";
+    rejected: "rejected";
+    quarantined: "quarantined";
     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;
@@ -2022,15 +2076,15 @@ declare const Attempt_v1: z.ZodObject<{
         failed: "failed";
         cancelled: "cancelled";
         prepared: "prepared";
+        rejected: "rejected";
+        quarantined: "quarantined";
         leased: "leased";
         launching: "launching";
         running: "running";
         receipt_submitted: "receipt_submitted";
         accepted: "accepted";
-        rejected: "rejected";
         inconclusive: "inconclusive";
         launch_failed: "launch_failed";
-        quarantined: "quarantined";
     }>;
     created_at: z.ZodString;
     updated_at: z.ZodString;
@@ -2244,15 +2298,15 @@ declare const AgentWorkFanInDecision_v1: z.ZodPipe<z.ZodObject<{
             failed: "failed";
             cancelled: "cancelled";
             prepared: "prepared";
+            rejected: "rejected";
+            quarantined: "quarantined";
             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>;
@@ -2287,7 +2341,7 @@ declare const AgentWorkFanInDecision_v1: z.ZodPipe<z.ZodObject<{
     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";
+        attempt_status: "blocked" | "verifying" | "verified" | "failed" | "cancelled" | "prepared" | "rejected" | "quarantined" | "leased" | "launching" | "running" | "receipt_submitted" | "accepted" | "inconclusive" | "launch_failed";
         trust_gap_count: number;
         conclusion: "rejected" | "selected" | "equivalent" | "unselected" | "missing_evidence";
         reason_codes: string[];
@@ -2330,7 +2384,7 @@ declare const AgentWorkFanInDecision_v1: z.ZodPipe<z.ZodObject<{
     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";
+        attempt_status: "blocked" | "verifying" | "verified" | "failed" | "cancelled" | "prepared" | "rejected" | "quarantined" | "leased" | "launching" | "running" | "receipt_submitted" | "accepted" | "inconclusive" | "launch_failed";
         trust_gap_count: number;
         conclusion: "rejected" | "selected" | "equivalent" | "unselected" | "missing_evidence";
         reason_codes: string[];
@@ -2578,12 +2632,97 @@ declare const ExecutionEnvelope_v1: z.ZodObject<{
     paths: z.ZodObject<{
         project_root: z.ZodString;
         execution_root: z.ZodString;
+        allocation_root: z.ZodOptional<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>>;
+    path_mappings: z.ZodArray<z.ZodUnion<readonly [z.ZodPreprocess<z.ZodObject<{
+        mapping_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        projection_id: z.ZodString;
+        repository_id: z.ZodString;
+        base_sha: z.ZodString;
+        native_host_id: z.ZodString;
+        request_digest: z.ZodString;
+        projection_digest: z.ZodString;
+        projection_mapping_digest: z.ZodString;
+        roots: z.ZodPreprocess<z.ZodObject<{
+            windows_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"declared">;
+            }, z.core.$strip>>;
+            wsl_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"git_observed">;
+                observation_digest: z.ZodString;
+            }, z.core.$strip>>;
+            native_repository: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_worktree: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+        mapping_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        mapping_kind: z.ZodLiteral<"native_linux">;
+        repository_id: z.ZodString;
+        base_sha: z.ZodString;
+        native_host_id: z.ZodString;
+        git_runtime: z.ZodString;
+        roots: z.ZodPreprocess<z.ZodObject<{
+            native_repository: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_worktree: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>]>>;
     exposed_environment_keys: z.ZodArray<z.ZodString>;
     created_at: z.ZodString;
 }, z.core.$strict>;
@@ -2615,8 +2754,8 @@ type ControllerLease_v1 = z.infer<typeof ControllerLease_v1>;
 declare const WorkspaceLeaseStatus: z.ZodEnum<{
     verifying: "verifying";
     active: "active";
-    receipt_submitted: "receipt_submitted";
     quarantined: "quarantined";
+    receipt_submitted: "receipt_submitted";
     released: "released";
     expired: "expired";
     reserved: "reserved";
@@ -2670,8 +2809,8 @@ declare const WorkspaceLease_v1: z.ZodObject<{
     status: z.ZodEnum<{
         verifying: "verifying";
         active: "active";
-        receipt_submitted: "receipt_submitted";
         quarantined: "quarantined";
+        receipt_submitted: "receipt_submitted";
         released: "released";
         expired: "expired";
         reserved: "reserved";
@@ -3543,6 +3682,18 @@ declare const WorkspaceObservation: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type WorkspaceObservation = z.infer<typeof WorkspaceObservation>;
+declare const HeartbeatWorkerSessionStatus: z.ZodEnum<{
+    awaiting_human: "awaiting_human";
+    running: "running";
+}>;
+type HeartbeatWorkerSessionStatus = z.infer<typeof HeartbeatWorkerSessionStatus>;
+declare const EndWorkerSessionStatus: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    cancelled: "cancelled";
+    lost: "lost";
+}>;
+type EndWorkerSessionStatus = z.infer<typeof EndWorkerSessionStatus>;
 
 /** Durable attempt state. Attempts exist before a workspace is allocated. */
 interface AttemptRecord {
@@ -3694,6 +3845,22 @@ interface WorkerAdapterBindingRecord {
     trustGapDimensions: string[];
     createdAt: string;
 }
+/** Immutable canonical envelope authorized for one launching Attempt. */
+interface LaunchEnvelopeBindingRecord {
+    runId: string;
+    attemptId: string;
+    workspaceLeaseId: string;
+    attemptRevision: number;
+    workspaceLeaseRevision: number;
+    authorizationMutationId: string;
+    envelopeId: string;
+    envelopeHash: string;
+    envelopeJson: string;
+    controllerId: string;
+    controllerLeaseId: string;
+    fencingToken: number;
+    createdAt: string;
+}
 interface WorkerSessionEvent {
     runId: string;
     attemptId: string;
@@ -3717,6 +3884,74 @@ interface AuthenticatedMutationInput {
     mutationId: string;
     now: string;
 }
+interface AuthenticatedWorkerMutationInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+}
+interface AttachWorkerSessionInput extends AuthenticatedWorkerMutationInput {
+    sessionId: string;
+    packetId: string;
+    packetHash: string;
+    executionEnvelopeId: string;
+    executionEnvelopeHash: string;
+    hostId: string;
+    workerRuntime: string;
+    gitRuntime: string;
+    backend: WorkerSessionBackend;
+    workerId: string;
+    model?: string;
+    startedAt: string;
+    adapter?: {
+        adapterId: string;
+        adapterVersion: string;
+        enforcementSummaryHash: string;
+        trustGapDimensions: string[];
+    };
+}
+interface BindLaunchEnvelopeInput {
+    runId: string;
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedRunRevision: number;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+    controller: ControllerLeaseCredential;
+    authorizationMutationId: string;
+    envelopeId: string;
+    envelopeHash: string;
+    envelopeJson: string;
+    /**
+     * Required for every new launch-envelope binding. It remains optional in
+     * the input type solely so callers can exactly replay an already-persisted
+     * legacy envelope-only binding during compatibility migration; it must not
+     * be omitted when creating a binding.
+     */
+    packetJson?: string;
+    createdAt: string;
+}
+/**
+ * Fenced fail-closed recovery for an Attempt stranded after launch authorization but before its
+ * immutable envelope and packet were durably bound. No envelope evidence is accepted here.
+ */
+interface ReconcileIncompleteLaunchInput extends AuthenticatedMutationInput {
+    attemptId: string;
+    workspaceLeaseId: string;
+    expectedAttemptRevision: number;
+    expectedWorkspaceLeaseRevision: number;
+}
+type LaunchEnvelopeBindingResult = {
+    bound: true;
+    binding: LaunchEnvelopeBindingRecord;
+    idempotentReplay: boolean;
+} | {
+    bound: false;
+    reason: WorkspaceMutationFailureReason;
+    currentAttemptRevision?: number;
+    currentWorkspaceLeaseRevision?: number;
+    currentRunRevision?: number;
+};
 interface AttemptReceiptRecord {
     receiptId: string;
     receiptHash: string;
@@ -3923,6 +4158,19 @@ type AttemptVerificationSubmissionResult = {
     currentSessionRevision?: number;
     currentRunRevision?: number;
 };
+interface HeartbeatWorkerSessionInput extends AuthenticatedWorkerMutationInput {
+    sessionId: string;
+    expectedSessionRevision: number;
+    status?: HeartbeatWorkerSessionStatus;
+}
+interface EndWorkerSessionInput extends AuthenticatedWorkerMutationInput {
+    sessionId: string;
+    expectedSessionRevision: number;
+    status: EndWorkerSessionStatus;
+    exitReason?: string;
+    exitCode?: number;
+    exitSummary?: string;
+}
 type WorkerSessionMutationResult = {
     updated: true;
     attempt: AttemptRecord;
@@ -4058,6 +4306,22 @@ interface AgentWorkFanoutStore {
     getFanInDecision(decisionId: string): Promise<FanInDecisionRecord | null>;
     getFanInDecisionForFanout(fanoutId: string): Promise<FanInDecisionRecord | null>;
 }
+/** Additive binding port for Stage 3 launch envelopes. */
+interface LaunchEnvelopeBindingStore {
+    bindLaunchEnvelope(input: BindLaunchEnvelopeInput): Promise<LaunchEnvelopeBindingResult>;
+    reconcileIncompleteLaunch(input: ReconcileIncompleteLaunchInput): Promise<WorkspaceMutationResult>;
+    getLaunchEnvelopeBinding(attemptId: string): Promise<LaunchEnvelopeBindingRecord | null>;
+}
+/** Additive Stage 3 persistence port; kept separate from the Stage 1 workspace contract. */
+interface WorkerSessionStore {
+    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[]>;
+}
 /** Additive immutable AgentTaskReceipt v2 persistence port. */
 interface AttemptReceiptStore {
     submitAttemptReceipt(input: SubmitAttemptReceiptInput): Promise<AttemptReceiptSubmissionResult>;
@@ -4078,6 +4342,70 @@ interface AttemptVerificationStore {
     listAttemptVerificationEvents(runId: string): Promise<AttemptVerificationEvent[]>;
 }
 
+interface WorktreeTarget extends WorkspaceIdentity {
+    /** Immutable full Git object ID used to create this Attempt workspace. */
+    baseSha: string;
+}
+interface BrokerOperationOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    boundaryAuthority?: BrokerBoundaryAuthority;
+}
+interface BrokerBoundaryAuthority {
+    operationId: string;
+    orchestrationLeaseId: string;
+    orchestrationLeaseRevision: number;
+    ownerId: string;
+}
+type BrokerOperation = "create" | "observe" | "remove";
+interface BrokerCommandEvidence {
+    executable: string;
+    args: string[];
+    cwd: string;
+    exitCode: number | null;
+    stdoutTail: string;
+    stderrTail: string;
+}
+type BrokerFailureReason = "invalid_base_sha" | "invalid_branch" | "invalid_path" | "runtime_mismatch" | "path_conflict" | "branch_conflict" | "containment_violation" | "identity_mismatch" | "dirty_workspace" | "command_failed" | "timeout" | "aborted";
+interface BrokerFailure {
+    ok: false;
+    operation: BrokerOperation;
+    reason: BrokerFailureReason;
+    message: string;
+    command?: BrokerCommandEvidence;
+    observation?: WorkspaceObservation;
+}
+interface CreateWorktreeSuccess {
+    ok: true;
+    outcome: "created" | "reused";
+    observation: WorkspaceObservation;
+}
+type CreateWorktreeResult = CreateWorktreeSuccess | BrokerFailure;
+interface ObserveWorktreeSuccess {
+    ok: true;
+    outcome: "observed";
+    observation: WorkspaceObservation;
+}
+type ObserveWorktreeResult = ObserveWorktreeSuccess | BrokerFailure;
+type WorktreePreservationReason = "dirty" | "missing" | "unregistered" | "wrong_repository" | "wrong_branch" | "identity_ambiguous";
+interface RemoveWorktreeSuccess {
+    ok: true;
+    outcome: "removed" | "preserved";
+    preservationReason?: WorktreePreservationReason;
+    observation: WorkspaceObservation;
+}
+type RemoveWorktreeResult = RemoveWorktreeSuccess | BrokerFailure;
+/**
+ * Git side-effect port. Durable ownership and fencing remain the
+ * WorkspaceLifecycleStore's responsibility; the broker only observes and
+ * mutates the declared runtime's Git worktree registry.
+ */
+interface GitWorktreeBroker {
+    create(target: WorktreeTarget, options?: BrokerOperationOptions): Promise<CreateWorktreeResult>;
+    observe(target: WorktreeTarget, options?: BrokerOperationOptions): Promise<ObserveWorktreeResult>;
+    remove(target: WorktreeTarget, options?: BrokerOperationOptions): Promise<RemoveWorktreeResult>;
+}
+
 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 {
@@ -4156,113 +4484,1396 @@ interface BoundedLaunchStatus {
     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 DirectoryIdentityBoundarySupport = {
+    readonly supported: true;
+    readonly platform: NodeJS.Platform;
+    readonly pathComparison: "case-sensitive";
+    readonly reasonCode: "native_linux_ready";
+} | {
+    readonly supported: false;
+    readonly platform: NodeJS.Platform;
+    readonly pathComparison: "case-sensitive" | "case-insensitive";
+    readonly reasonCode: "windows_native_boundary_unavailable" | "macos_unsupported" | "unsupported_platform" | "case_insensitive_runtime" | "procfs_unavailable";
+};
+interface DirectoryIdentityPathProbe {
+    readonly verified: boolean;
+    readonly filesystem: "native_linux" | "wsl_drvfs_9p" | "unknown";
+    readonly reasonCode: "directory_verified" | "wsl_drvfs_9p" | "invalid_native_path" | "path_unavailable" | "filesystem_unverified";
 }
-type AttemptLaunchBundleResult = AttemptLaunchBundleSuccess | AgentWorkLifecycleFailure;
 
-declare const AttemptStartRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+declare const AgentWorkContainmentPreflightRequestSchema: 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;
+}, z.core.$strict>;
+declare const AgentWorkContainmentPreflightRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    runtime: z.ZodObject<{
+        repositoryId: z.ZodString;
+        repositoryRoot: z.ZodString;
+        worktreeRoot: z.ZodString;
+        gitRuntime: z.ZodString;
+        pathComparison: z.ZodEnum<{
+            "case-sensitive": "case-sensitive";
+            "case-insensitive": "case-insensitive";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+type AgentWorkContainmentPreflightRequest = z.infer<typeof AgentWorkContainmentPreflightRequestSchema>;
+type AgentWorkContainmentCapabilityState = "native_ready" | "broker_required" | "unsupported";
+type AgentWorkContainmentReasonCode = "native_linux_ready" | "windows_native_boundary_unavailable"
+/** Legacy v1 reason retained for persisted result compatibility. */
+ | "windows_requires_native_wsl_broker" | "macos_unsupported" | "unsupported_platform" | "case_insensitive_runtime" | "procfs_unavailable" | "repository_root_invalid" | "worktree_root_invalid" | "path_roots_overlap" | "repository_root_wsl_drvfs_9p" | "repository_git_wsl_drvfs_9p" | "worktree_root_wsl_drvfs_9p" | "repository_root_unavailable" | "repository_git_directory_unavailable" | "worktree_root_unavailable" | "repository_root_filesystem_unverified" | "repository_git_filesystem_unverified" | "worktree_root_filesystem_unverified";
+type AgentWorkContainmentNextAction = "construct_attempt_packet" | "install_native_windows_boundary" | "provision_native_wsl_projection" | "select_native_case_sensitive_linux_runtime" | "correct_declared_paths" | "rerun_containment_preflight";
+interface AgentWorkContainmentPathStatus {
+    readonly inspection: "identity_verified" | "filesystem_verified" | "syntactic_only" | "unverified" | "not_checked";
+    readonly filesystem: "native_linux" | "wsl_drvfs_9p" | "unknown";
+}
+interface AgentWorkContainmentPreflightResult {
+    readonly schemaVersion: "1.0.0";
+    readonly operation: "agent-work.containment.preflight";
+    readonly bindingDigest: `sha256:${string}`;
+    readonly state: AgentWorkContainmentCapabilityState;
+    readonly reasonCode: AgentWorkContainmentReasonCode;
+    readonly physicalContainmentAvailable: boolean;
+    readonly projectionRequired: boolean;
+    readonly runtime: {
+        readonly platform: "linux" | "windows" | "macos" | "other";
+        readonly pathComparison: "case-sensitive" | "case-insensitive";
+    };
+    readonly paths: {
+        readonly repositoryRoot: AgentWorkContainmentPathStatus;
+        readonly repositoryGitDirectory: AgentWorkContainmentPathStatus;
+        readonly worktreeRoot: AgentWorkContainmentPathStatus;
+    };
+    readonly nextActions: readonly AgentWorkContainmentNextAction[];
+}
+interface AgentWorkContainmentPreflightInputError {
+    readonly code: "invalid_input";
+    readonly message: "Invalid containment preflight input";
+    readonly issues: ReadonlyArray<{
+        readonly path: string;
+        readonly message: string;
+    }>;
+}
+type AgentWorkContainmentPreflightHandlerResult = {
+    readonly ok: true;
+    readonly result: AgentWorkContainmentPreflightResult;
+} | {
+    readonly ok: false;
+    readonly error: AgentWorkContainmentPreflightInputError;
+};
+interface AgentWorkContainmentPreflightHandler {
+    preflight(request: unknown): Promise<AgentWorkContainmentPreflightHandlerResult>;
+}
+interface AgentWorkContainmentCapabilityDependencies {
+    runtimeProbe?: (pathComparison: "case-sensitive" | "case-insensitive") => DirectoryIdentityBoundarySupport;
+    pathProbe?: (absolutePath: string, label: string) => DirectoryIdentityPathProbe;
+}
+/** Stateless, read-only capability owner shared by CLI and MCP adapters. */
+declare class AgentWorkContainmentCapabilityService {
+    private readonly runtimeProbe;
+    private readonly pathProbe;
+    constructor(dependencies?: AgentWorkContainmentCapabilityDependencies);
+    preflight(request: AgentWorkContainmentPreflightRequest): AgentWorkContainmentPreflightResult;
+}
+declare function createAgentWorkContainmentPreflightHandler(service?: AgentWorkContainmentCapabilityService): AgentWorkContainmentPreflightHandler;
+
+declare const NATIVE_WSL_PROJECTION_CONTRACT_VERSION: "1.0.0";
+declare const NATIVE_WSL_PROJECTION_HASH_PROFILE: "canonical-json-domain-separated-v1";
+declare const NativeDirectoryIdentityClaim_v1: z.ZodPreprocess<z.ZodObject<{
+    device: z.ZodString;
+    inode: z.ZodString;
+}, z.core.$strip>>;
+type NativeDirectoryIdentityClaim_v1 = z.infer<typeof NativeDirectoryIdentityClaim_v1>;
+declare const ProjectionRequestShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly request_id: z.ZodString;
+    readonly repository: z.ZodPreprocess<z.ZodObject<{
+        id: z.ZodString;
+        expected_remote_hash: z.ZodString;
+    }, z.core.$strip>>;
+    readonly source: z.ZodPreprocess<z.ZodObject<{
+        windows_runtime: z.ZodString;
+        windows_repository_path: z.ZodString;
+        wsl_distribution: z.ZodString;
+        wsl_git_runtime: z.ZodString;
+        wsl_repository_path: z.ZodString;
+        head_policy: z.ZodEnum<{
+            observe: "observe";
+            require_base: "require_base";
+        }>;
+        dirty_policy: z.ZodEnum<{
+            require_clean: "require_clean";
+            committed_base_only: "committed_base_only";
+        }>;
+    }, z.core.$strip>>;
+    readonly native: z.ZodPreprocess<z.ZodObject<{
+        host_id: z.ZodString;
+        git_runtime: z.ZodString;
+        projection_root: z.ZodString;
+        worktree_root: z.ZodString;
+    }, z.core.$strip>>;
+    readonly base_sha: z.ZodString;
+};
+declare const NativeWslProjectionRequest_v1: z.ZodPreprocess<z.ZodObject<{
+    request_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    request_id: z.ZodString;
+    repository: z.ZodPreprocess<z.ZodObject<{
+        id: z.ZodString;
+        expected_remote_hash: z.ZodString;
+    }, z.core.$strip>>;
+    source: z.ZodPreprocess<z.ZodObject<{
+        windows_runtime: z.ZodString;
+        windows_repository_path: z.ZodString;
+        wsl_distribution: z.ZodString;
+        wsl_git_runtime: z.ZodString;
+        wsl_repository_path: z.ZodString;
+        head_policy: z.ZodEnum<{
+            observe: "observe";
+            require_base: "require_base";
+        }>;
+        dirty_policy: z.ZodEnum<{
+            require_clean: "require_clean";
+            committed_base_only: "committed_base_only";
+        }>;
+    }, z.core.$strip>>;
+    native: z.ZodPreprocess<z.ZodObject<{
+        host_id: z.ZodString;
+        git_runtime: z.ZodString;
+        projection_root: z.ZodString;
+        worktree_root: z.ZodString;
+    }, z.core.$strip>>;
+    base_sha: z.ZodString;
+}, z.core.$strip>>;
+type NativeWslProjectionRequest_v1 = z.infer<typeof NativeWslProjectionRequest_v1>;
+declare const NativeWslProjectionRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodPreprocess<z.ZodObject<{
+    request_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    request_id: z.ZodString;
+    repository: z.ZodPreprocess<z.ZodObject<{
+        id: z.ZodString;
+        expected_remote_hash: z.ZodString;
+    }, z.core.$strip>>;
+    source: z.ZodPreprocess<z.ZodObject<{
+        windows_runtime: z.ZodString;
+        windows_repository_path: z.ZodString;
+        wsl_distribution: z.ZodString;
+        wsl_git_runtime: z.ZodString;
+        wsl_repository_path: z.ZodString;
+        head_policy: z.ZodEnum<{
+            observe: "observe";
+            require_base: "require_base";
+        }>;
+        dirty_policy: z.ZodEnum<{
+            require_clean: "require_clean";
+            committed_base_only: "committed_base_only";
+        }>;
+    }, z.core.$strip>>;
+    native: z.ZodPreprocess<z.ZodObject<{
+        host_id: z.ZodString;
+        git_runtime: z.ZodString;
+        projection_root: z.ZodString;
+        worktree_root: z.ZodString;
+    }, z.core.$strip>>;
+    base_sha: z.ZodString;
+}, z.core.$strip>>>;
+declare function createNativeWslProjectionRequest(input: z.input<z.ZodObject<typeof ProjectionRequestShape>>): NativeWslProjectionRequest_v1;
+declare const SourceObservationShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly repository_id: z.ZodString;
+    readonly request_digest: z.ZodString;
+    readonly observed_remote_hash: z.ZodString;
+    readonly source_head_sha: z.ZodString;
+    readonly requested_object_sha: z.ZodString;
+    readonly requested_object_type: z.ZodEnum<{
+        commit: "commit";
+        other: "other";
+        missing: "missing";
+    }>;
+    readonly cleanliness: z.ZodEnum<{
+        unknown: "unknown";
+        clean: "clean";
+        dirty: "dirty";
+    }>;
+    readonly observed_at: z.ZodString;
+};
+declare const NativeWslSourceObservation_v1: z.ZodPreprocess<z.ZodObject<{
+    observation_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    repository_id: z.ZodString;
+    request_digest: z.ZodString;
+    observed_remote_hash: z.ZodString;
+    source_head_sha: z.ZodString;
+    requested_object_sha: z.ZodString;
+    requested_object_type: z.ZodEnum<{
+        commit: "commit";
+        other: "other";
+        missing: "missing";
+    }>;
+    cleanliness: z.ZodEnum<{
+        unknown: "unknown";
+        clean: "clean";
+        dirty: "dirty";
+    }>;
+    observed_at: z.ZodString;
+}, z.core.$strip>>;
+type NativeWslSourceObservation_v1 = z.infer<typeof NativeWslSourceObservation_v1>;
+declare function createNativeWslSourceObservation(input: z.input<z.ZodObject<typeof SourceObservationShape>>): NativeWslSourceObservation_v1;
+declare const ProjectionPathMappingShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly projection_id: z.ZodString;
+    readonly repository_id: z.ZodString;
+    readonly base_sha: z.ZodString;
+    readonly request_digest: z.ZodString;
+    readonly roots: z.ZodPreprocess<z.ZodObject<{
+        windows_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"declared">;
+        }, z.core.$strip>>;
+        wsl_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"git_observed">;
+            observation_digest: z.ZodString;
+        }, z.core.$strip>>;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+};
+declare const NativeWslProjectionPathMapping_v1: z.ZodPreprocess<z.ZodObject<{
+    mapping_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    projection_id: z.ZodString;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    request_digest: z.ZodString;
+    roots: z.ZodPreprocess<z.ZodObject<{
+        windows_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"declared">;
+        }, z.core.$strip>>;
+        wsl_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"git_observed">;
+            observation_digest: z.ZodString;
+        }, z.core.$strip>>;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+type NativeWslProjectionPathMapping_v1 = z.infer<typeof NativeWslProjectionPathMapping_v1>;
+declare function createNativeWslProjectionPathMapping(input: z.input<z.ZodObject<typeof ProjectionPathMappingShape>>): NativeWslProjectionPathMapping_v1;
+declare const ProjectionManifestShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly projection_id: z.ZodString;
+    readonly repository_id: z.ZodString;
+    readonly base_sha: z.ZodString;
+    readonly request_digest: z.ZodString;
+    readonly source_observation: z.ZodPreprocess<z.ZodObject<{
+        observation_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        repository_id: z.ZodString;
+        request_digest: z.ZodString;
+        observed_remote_hash: z.ZodString;
+        source_head_sha: z.ZodString;
+        requested_object_sha: z.ZodString;
+        requested_object_type: z.ZodEnum<{
+            commit: "commit";
+            other: "other";
+            missing: "missing";
+        }>;
+        cleanliness: z.ZodEnum<{
+            unknown: "unknown";
+            clean: "clean";
+            dirty: "dirty";
+        }>;
+        observed_at: z.ZodString;
+    }, z.core.$strip>>;
+    readonly native_host_id: z.ZodString;
+    readonly native_repository: z.ZodPreprocess<z.ZodObject<{
+        path: z.ZodString;
+        directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+        git_directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+        head_sha: z.ZodString;
+    }, z.core.$strip>>;
+    readonly native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+        path: z.ZodString;
+        directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    readonly path_mapping: z.ZodPreprocess<z.ZodObject<{
+        mapping_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        projection_id: z.ZodString;
+        repository_id: z.ZodString;
+        base_sha: z.ZodString;
+        request_digest: z.ZodString;
+        roots: z.ZodPreprocess<z.ZodObject<{
+            windows_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"declared">;
+            }, z.core.$strip>>;
+            wsl_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"git_observed">;
+                observation_digest: z.ZodString;
+            }, z.core.$strip>>;
+            native_repository: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    readonly created_at: z.ZodString;
+};
+declare const NativeWslProjectionManifest_v1: z.ZodPreprocess<z.ZodObject<{
+    manifest_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    projection_id: z.ZodString;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    request_digest: z.ZodString;
+    source_observation: z.ZodPreprocess<z.ZodObject<{
+        observation_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        repository_id: z.ZodString;
+        request_digest: z.ZodString;
+        observed_remote_hash: z.ZodString;
+        source_head_sha: z.ZodString;
+        requested_object_sha: z.ZodString;
+        requested_object_type: z.ZodEnum<{
+            commit: "commit";
+            other: "other";
+            missing: "missing";
+        }>;
+        cleanliness: z.ZodEnum<{
+            unknown: "unknown";
+            clean: "clean";
+            dirty: "dirty";
+        }>;
+        observed_at: z.ZodString;
+    }, z.core.$strip>>;
+    native_host_id: z.ZodString;
+    native_repository: z.ZodPreprocess<z.ZodObject<{
+        path: z.ZodString;
+        directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+        git_directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+        head_sha: z.ZodString;
+    }, z.core.$strip>>;
+    native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+        path: z.ZodString;
+        directory_identity: z.ZodPreprocess<z.ZodObject<{
+            device: z.ZodString;
+            inode: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    path_mapping: z.ZodPreprocess<z.ZodObject<{
+        mapping_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        projection_id: z.ZodString;
+        repository_id: z.ZodString;
+        base_sha: z.ZodString;
+        request_digest: z.ZodString;
+        roots: z.ZodPreprocess<z.ZodObject<{
+            windows_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"declared">;
+            }, z.core.$strip>>;
+            wsl_source: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"git_observed">;
+                observation_digest: z.ZodString;
+            }, z.core.$strip>>;
+            native_repository: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+                runtime_id: z.ZodString;
+                path: z.ZodString;
+                verification: z.ZodLiteral<"directory_identity">;
+                directory_identity: z.ZodPreprocess<z.ZodObject<{
+                    device: z.ZodString;
+                    inode: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    created_at: z.ZodString;
+}, z.core.$strip>>;
+type NativeWslProjectionManifest_v1 = z.infer<typeof NativeWslProjectionManifest_v1>;
+declare function createNativeWslProjectionManifest(input: z.input<z.ZodObject<typeof ProjectionManifestShape>>): NativeWslProjectionManifest_v1;
+declare const ExecutionPathMappingShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly projection_id: z.ZodString;
+    readonly repository_id: z.ZodString;
+    readonly base_sha: z.ZodString;
+    readonly native_host_id: z.ZodString;
+    readonly request_digest: z.ZodString;
+    readonly projection_digest: z.ZodString;
+    readonly projection_mapping_digest: z.ZodString;
+    readonly roots: z.ZodPreprocess<z.ZodObject<{
+        windows_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"declared">;
+        }, z.core.$strip>>;
+        wsl_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"git_observed">;
+            observation_digest: z.ZodString;
+        }, z.core.$strip>>;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+};
+declare const NativeWslExecutionPathMapping_v1: z.ZodPreprocess<z.ZodObject<{
+    mapping_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    projection_id: z.ZodString;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    native_host_id: z.ZodString;
+    request_digest: z.ZodString;
+    projection_digest: z.ZodString;
+    projection_mapping_digest: z.ZodString;
+    roots: z.ZodPreprocess<z.ZodObject<{
+        windows_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"declared">;
+        }, z.core.$strip>>;
+        wsl_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"git_observed">;
+            observation_digest: z.ZodString;
+        }, z.core.$strip>>;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+type NativeWslExecutionPathMapping_v1 = z.infer<typeof NativeWslExecutionPathMapping_v1>;
+declare function createNativeWslExecutionPathMapping(input: z.input<z.ZodObject<typeof ExecutionPathMappingShape>>): NativeWslExecutionPathMapping_v1;
+declare const NativeExecutionPathMappingShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly mapping_kind: z.ZodLiteral<"native_linux">;
+    readonly repository_id: z.ZodString;
+    readonly base_sha: z.ZodString;
+    readonly native_host_id: z.ZodString;
+    readonly git_runtime: z.ZodString;
+    readonly roots: z.ZodPreprocess<z.ZodObject<{
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+};
+declare const NativeExecutionPathMapping_v1: z.ZodPreprocess<z.ZodObject<{
+    mapping_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    mapping_kind: z.ZodLiteral<"native_linux">;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    native_host_id: z.ZodString;
+    git_runtime: z.ZodString;
+    roots: z.ZodPreprocess<z.ZodObject<{
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+type NativeExecutionPathMapping_v1 = z.infer<typeof NativeExecutionPathMapping_v1>;
+declare function createNativeExecutionPathMapping(input: z.input<z.ZodObject<typeof NativeExecutionPathMappingShape>>): NativeExecutionPathMapping_v1;
+declare const AgentExecutionPathMapping_v1: z.ZodUnion<readonly [z.ZodPreprocess<z.ZodObject<{
+    mapping_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    projection_id: z.ZodString;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    native_host_id: z.ZodString;
+    request_digest: z.ZodString;
+    projection_digest: z.ZodString;
+    projection_mapping_digest: z.ZodString;
+    roots: z.ZodPreprocess<z.ZodObject<{
+        windows_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"declared">;
+        }, z.core.$strip>>;
+        wsl_source: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"git_observed">;
+            observation_digest: z.ZodString;
+        }, z.core.$strip>>;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    mapping_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    mapping_kind: z.ZodLiteral<"native_linux">;
+    repository_id: z.ZodString;
+    base_sha: z.ZodString;
+    native_host_id: z.ZodString;
+    git_runtime: z.ZodString;
+    roots: z.ZodPreprocess<z.ZodObject<{
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        native_worktree: z.ZodPreprocess<z.ZodObject<{
+            runtime_id: z.ZodString;
+            path: z.ZodString;
+            verification: z.ZodLiteral<"directory_identity">;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>>]>;
+type AgentExecutionPathMapping_v1 = z.infer<typeof AgentExecutionPathMapping_v1>;
+interface AgentExecutionPathBindingContext {
+    repositoryId: string;
+    baseSha: string;
+    hostId: string;
+    gitRuntime: string;
+    repositoryRoot: string;
+    allocationRoot: string;
+    worktreePath: string;
+}
+type AgentExecutionPathBindingValidation = {
+    valid: true;
+    kind: "native_wsl_projection" | "native_linux";
+    mappingDigest: string;
+} | {
+    valid: false;
+    reason: "mapping_count" | "repository_identity" | "base_identity" | "host_identity" | "runtime_identity" | "repository_path" | "allocation_path" | "worktree_path" | "directory_identity";
+};
+/** Pure identity validation shared by durable lifecycle consumers. */
+declare function validateAgentExecutionPathBinding(mappings: readonly AgentExecutionPathMapping_v1[], context: AgentExecutionPathBindingContext): AgentExecutionPathBindingValidation;
+declare const NativeWslProjectionOutcome: z.ZodEnum<{
+    reused: "reused";
+    prepared: "prepared";
+    rejected: "rejected";
+    quarantined: "quarantined";
+}>;
+type NativeWslProjectionOutcome = z.infer<typeof NativeWslProjectionOutcome>;
+declare const NativeWslProjectionReasonCode: z.ZodEnum<{
+    operation_failed: "operation_failed";
+    projection_prepared: "projection_prepared";
+    projection_reused: "projection_reused";
+    source_dirty: "source_dirty";
+    source_head_mismatch: "source_head_mismatch";
+    source_object_missing: "source_object_missing";
+    source_object_not_commit: "source_object_not_commit";
+    repository_identity_mismatch: "repository_identity_mismatch";
+    source_replaced: "source_replaced";
+    native_state_stale: "native_state_stale";
+    native_state_conflict: "native_state_conflict";
+    staging_interrupted: "staging_interrupted";
+    concurrent_request: "concurrent_request";
+    cleanup_failed_quarantined: "cleanup_failed_quarantined";
+    unsupported_filesystem: "unsupported_filesystem";
+    containment_unavailable: "containment_unavailable";
+}>;
+type NativeWslProjectionReasonCode = z.infer<typeof NativeWslProjectionReasonCode>;
+declare const ProjectionReceiptShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly request_id: z.ZodString;
+    readonly request_digest: z.ZodString;
+    readonly outcome: z.ZodEnum<{
+        reused: "reused";
+        prepared: "prepared";
+        rejected: "rejected";
+        quarantined: "quarantined";
+    }>;
+    readonly reason_code: z.ZodEnum<{
+        operation_failed: "operation_failed";
+        projection_prepared: "projection_prepared";
+        projection_reused: "projection_reused";
+        source_dirty: "source_dirty";
+        source_head_mismatch: "source_head_mismatch";
+        source_object_missing: "source_object_missing";
+        source_object_not_commit: "source_object_not_commit";
+        repository_identity_mismatch: "repository_identity_mismatch";
+        source_replaced: "source_replaced";
+        native_state_stale: "native_state_stale";
+        native_state_conflict: "native_state_conflict";
+        staging_interrupted: "staging_interrupted";
+        concurrent_request: "concurrent_request";
+        cleanup_failed_quarantined: "cleanup_failed_quarantined";
+        unsupported_filesystem: "unsupported_filesystem";
+        containment_unavailable: "containment_unavailable";
+    }>;
+    readonly source_observation_digest: z.ZodOptional<z.ZodString>;
+    readonly projection_digest: z.ZodOptional<z.ZodString>;
+    readonly mapping_digest: z.ZodOptional<z.ZodString>;
+    readonly completed_at: z.ZodString;
+};
+declare const NativeWslProjectionReceipt_v1: z.ZodPreprocess<z.ZodObject<{
+    receipt_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    request_id: z.ZodString;
+    request_digest: z.ZodString;
+    outcome: z.ZodEnum<{
+        reused: "reused";
+        prepared: "prepared";
+        rejected: "rejected";
+        quarantined: "quarantined";
+    }>;
+    reason_code: z.ZodEnum<{
+        operation_failed: "operation_failed";
+        projection_prepared: "projection_prepared";
+        projection_reused: "projection_reused";
+        source_dirty: "source_dirty";
+        source_head_mismatch: "source_head_mismatch";
+        source_object_missing: "source_object_missing";
+        source_object_not_commit: "source_object_not_commit";
+        repository_identity_mismatch: "repository_identity_mismatch";
+        source_replaced: "source_replaced";
+        native_state_stale: "native_state_stale";
+        native_state_conflict: "native_state_conflict";
+        staging_interrupted: "staging_interrupted";
+        concurrent_request: "concurrent_request";
+        cleanup_failed_quarantined: "cleanup_failed_quarantined";
+        unsupported_filesystem: "unsupported_filesystem";
+        containment_unavailable: "containment_unavailable";
+    }>;
+    source_observation_digest: z.ZodOptional<z.ZodString>;
+    projection_digest: z.ZodOptional<z.ZodString>;
+    mapping_digest: z.ZodOptional<z.ZodString>;
+    completed_at: z.ZodString;
+}, z.core.$strip>>;
+type NativeWslProjectionReceipt_v1 = z.infer<typeof NativeWslProjectionReceipt_v1>;
+declare function createNativeWslProjectionReceipt(input: z.input<z.ZodObject<typeof ProjectionReceiptShape>>): NativeWslProjectionReceipt_v1;
+declare const ProjectionSelectionShape: {
+    readonly schema_version: z.ZodLiteral<"1.0.0">;
+    readonly manifest_digest: z.ZodString;
+    readonly receipt: z.ZodPreprocess<z.ZodObject<{
+        receipt_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        request_digest: z.ZodString;
+        outcome: z.ZodEnum<{
+            reused: "reused";
+            prepared: "prepared";
+            rejected: "rejected";
+            quarantined: "quarantined";
+        }>;
+        reason_code: z.ZodEnum<{
+            operation_failed: "operation_failed";
+            projection_prepared: "projection_prepared";
+            projection_reused: "projection_reused";
+            source_dirty: "source_dirty";
+            source_head_mismatch: "source_head_mismatch";
+            source_object_missing: "source_object_missing";
+            source_object_not_commit: "source_object_not_commit";
+            repository_identity_mismatch: "repository_identity_mismatch";
+            source_replaced: "source_replaced";
+            native_state_stale: "native_state_stale";
+            native_state_conflict: "native_state_conflict";
+            staging_interrupted: "staging_interrupted";
+            concurrent_request: "concurrent_request";
+            cleanup_failed_quarantined: "cleanup_failed_quarantined";
+            unsupported_filesystem: "unsupported_filesystem";
+            containment_unavailable: "containment_unavailable";
+        }>;
+        source_observation_digest: z.ZodOptional<z.ZodString>;
+        projection_digest: z.ZodOptional<z.ZodString>;
+        mapping_digest: z.ZodOptional<z.ZodString>;
+        completed_at: z.ZodString;
+    }, z.core.$strip>>;
+    readonly source_observation: z.ZodPreprocess<z.ZodObject<{
+        observation_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        repository_id: z.ZodString;
+        request_digest: z.ZodString;
+        observed_remote_hash: z.ZodString;
+        source_head_sha: z.ZodString;
+        requested_object_sha: z.ZodString;
+        requested_object_type: z.ZodEnum<{
+            commit: "commit";
+            other: "other";
+            missing: "missing";
+        }>;
+        cleanliness: z.ZodEnum<{
+            unknown: "unknown";
+            clean: "clean";
+            dirty: "dirty";
+        }>;
+        observed_at: z.ZodString;
+    }, z.core.$strip>>;
+};
+/**
+ * Engine-authored current selection authority. Its public digest is only an
+ * integrity identifier; provenance comes from the identity-anchored engine
+ * record that launch preparation resolves.
+ */
+declare const NativeWslProjectionSelection_v1: z.ZodPreprocess<z.ZodObject<{
+    selection_digest: z.ZodString;
+    schema_version: z.ZodLiteral<"1.0.0">;
+    manifest_digest: z.ZodString;
+    receipt: z.ZodPreprocess<z.ZodObject<{
+        receipt_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        request_digest: z.ZodString;
+        outcome: z.ZodEnum<{
+            reused: "reused";
+            prepared: "prepared";
+            rejected: "rejected";
+            quarantined: "quarantined";
+        }>;
+        reason_code: z.ZodEnum<{
+            operation_failed: "operation_failed";
+            projection_prepared: "projection_prepared";
+            projection_reused: "projection_reused";
+            source_dirty: "source_dirty";
+            source_head_mismatch: "source_head_mismatch";
+            source_object_missing: "source_object_missing";
+            source_object_not_commit: "source_object_not_commit";
+            repository_identity_mismatch: "repository_identity_mismatch";
+            source_replaced: "source_replaced";
+            native_state_stale: "native_state_stale";
+            native_state_conflict: "native_state_conflict";
+            staging_interrupted: "staging_interrupted";
+            concurrent_request: "concurrent_request";
+            cleanup_failed_quarantined: "cleanup_failed_quarantined";
+            unsupported_filesystem: "unsupported_filesystem";
+            containment_unavailable: "containment_unavailable";
+        }>;
+        source_observation_digest: z.ZodOptional<z.ZodString>;
+        projection_digest: z.ZodOptional<z.ZodString>;
+        mapping_digest: z.ZodOptional<z.ZodString>;
+        completed_at: z.ZodString;
+    }, z.core.$strip>>;
+    source_observation: z.ZodPreprocess<z.ZodObject<{
+        observation_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        repository_id: z.ZodString;
+        request_digest: z.ZodString;
+        observed_remote_hash: z.ZodString;
+        source_head_sha: z.ZodString;
+        requested_object_sha: z.ZodString;
+        requested_object_type: z.ZodEnum<{
+            commit: "commit";
+            other: "other";
+            missing: "missing";
+        }>;
+        cleanliness: z.ZodEnum<{
+            unknown: "unknown";
+            clean: "clean";
+            dirty: "dirty";
+        }>;
+        observed_at: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>;
+type NativeWslProjectionSelection_v1 = z.infer<typeof NativeWslProjectionSelection_v1>;
+declare function createNativeWslProjectionSelection(input: z.input<z.ZodObject<typeof ProjectionSelectionShape>>): NativeWslProjectionSelection_v1;
+declare const NativeWslProjectionInventoryState: z.ZodEnum<{
+    ready: "ready";
+    invalid: "invalid";
+    quarantined: "quarantined";
+    absent: "absent";
+    staging: "staging";
+    interrupted: "interrupted";
+    conflicting: "conflicting";
+}>;
+type NativeWslProjectionInventoryState = z.infer<typeof NativeWslProjectionInventoryState>;
+declare const NativeWslProjectionPlanAction: z.ZodEnum<{
+    prepare_staging: "prepare_staging";
+    reuse_ready: "reuse_ready";
+    wait_for_same_request: "wait_for_same_request";
+    quarantine_then_prepare: "quarantine_then_prepare";
+    cleanup_quarantine_then_prepare: "cleanup_quarantine_then_prepare";
+    refuse_conflict: "refuse_conflict";
+}>;
+type NativeWslProjectionPlanAction = z.infer<typeof NativeWslProjectionPlanAction>;
+declare const NativeWslProjectionPlanReason: z.ZodEnum<{
+    projection_absent: "projection_absent";
+    projection_exact_match: "projection_exact_match";
+    projection_staging_same_request: "projection_staging_same_request";
+    projection_staging_conflict: "projection_staging_conflict";
+    projection_stale: "projection_stale";
+    projection_quarantined: "projection_quarantined";
+    projection_invalid: "projection_invalid";
+    projection_interrupted: "projection_interrupted";
+    projection_conflicting: "projection_conflicting";
+}>;
+type NativeWslProjectionPlanReason = z.infer<typeof NativeWslProjectionPlanReason>;
+declare function nativeWslProjectionId(requestDigest: string): string;
+
+declare const NativeWslProjectionInventoryObservation_v1: z.ZodUnion<readonly [z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"absent">;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"ready">;
+    manifest: z.ZodPreprocess<z.ZodObject<{
+        manifest_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        projection_id: z.ZodString;
+        repository_id: z.ZodString;
+        base_sha: z.ZodString;
+        request_digest: z.ZodString;
+        source_observation: z.ZodPreprocess<z.ZodObject<{
+            observation_digest: z.ZodString;
+            schema_version: z.ZodLiteral<"1.0.0">;
+            repository_id: z.ZodString;
+            request_digest: z.ZodString;
+            observed_remote_hash: z.ZodString;
+            source_head_sha: z.ZodString;
+            requested_object_sha: z.ZodString;
+            requested_object_type: z.ZodEnum<{
+                commit: "commit";
+                other: "other";
+                missing: "missing";
+            }>;
+            cleanliness: z.ZodEnum<{
+                unknown: "unknown";
+                clean: "clean";
+                dirty: "dirty";
+            }>;
+            observed_at: z.ZodString;
+        }, z.core.$strip>>;
+        native_host_id: z.ZodString;
+        native_repository: z.ZodPreprocess<z.ZodObject<{
+            path: z.ZodString;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+            git_directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+            head_sha: z.ZodString;
+        }, z.core.$strip>>;
+        native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+            path: z.ZodString;
+            directory_identity: z.ZodPreprocess<z.ZodObject<{
+                device: z.ZodString;
+                inode: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        path_mapping: z.ZodPreprocess<z.ZodObject<{
+            mapping_digest: z.ZodString;
+            schema_version: z.ZodLiteral<"1.0.0">;
+            projection_id: z.ZodString;
+            repository_id: z.ZodString;
+            base_sha: z.ZodString;
+            request_digest: z.ZodString;
+            roots: z.ZodPreprocess<z.ZodObject<{
+                windows_source: z.ZodPreprocess<z.ZodObject<{
+                    runtime_id: z.ZodString;
+                    path: z.ZodString;
+                    verification: z.ZodLiteral<"declared">;
+                }, z.core.$strip>>;
+                wsl_source: z.ZodPreprocess<z.ZodObject<{
+                    runtime_id: z.ZodString;
+                    path: z.ZodString;
+                    verification: z.ZodLiteral<"git_observed">;
+                    observation_digest: z.ZodString;
+                }, z.core.$strip>>;
+                native_repository: z.ZodPreprocess<z.ZodObject<{
+                    runtime_id: z.ZodString;
+                    path: z.ZodString;
+                    verification: z.ZodLiteral<"directory_identity">;
+                    directory_identity: z.ZodPreprocess<z.ZodObject<{
+                        device: z.ZodString;
+                        inode: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                native_worktree_root: z.ZodPreprocess<z.ZodObject<{
+                    runtime_id: z.ZodString;
+                    path: z.ZodString;
+                    verification: z.ZodLiteral<"directory_identity">;
+                    directory_identity: z.ZodPreprocess<z.ZodObject<{
+                        device: z.ZodString;
+                        inode: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        created_at: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"staging">;
+    projection_id: z.ZodString;
+    request_digest: z.ZodString;
+    started_at: z.ZodString;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"quarantined">;
+    projection_id: z.ZodOptional<z.ZodString>;
+    request_digest: z.ZodOptional<z.ZodString>;
+    quarantined_at: z.ZodString;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"invalid">;
+    projection_id: z.ZodOptional<z.ZodString>;
+    request_digest: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"interrupted">;
+    projection_id: z.ZodString;
+    request_digest: z.ZodString;
+    started_at: z.ZodString;
+}, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+    state: z.ZodLiteral<"conflicting">;
+    projection_id: z.ZodString;
+    request_digest: z.ZodOptional<z.ZodString>;
+    observed_at: z.ZodString;
+}, z.core.$strip>>]>;
+type NativeWslProjectionInventoryObservation_v1 = z.infer<typeof NativeWslProjectionInventoryObservation_v1>;
+declare const NativeWslProjectionNextAction: z.ZodEnum<{
+    prepare_projection_staging: "prepare_projection_staging";
+    reuse_projection: "reuse_projection";
+    retry_after_active_request: "retry_after_active_request";
+    quarantine_observed_projection: "quarantine_observed_projection";
+    cleanup_quarantined_projection: "cleanup_quarantined_projection";
+    stop_and_report_conflict: "stop_and_report_conflict";
+}>;
+type NativeWslProjectionNextAction = z.infer<typeof NativeWslProjectionNextAction>;
+declare const NativeWslProjectionPlan_v1: z.ZodPreprocess<z.ZodObject<{
+    schema_version: z.ZodLiteral<"1.0.0">;
+    projection_id: z.ZodString;
+    request_digest: z.ZodString;
+    inventory_state: z.ZodEnum<{
+        ready: "ready";
+        invalid: "invalid";
+        quarantined: "quarantined";
+        absent: "absent";
+        staging: "staging";
+        interrupted: "interrupted";
+        conflicting: "conflicting";
+    }>;
+    action: z.ZodEnum<{
+        prepare_staging: "prepare_staging";
+        reuse_ready: "reuse_ready";
+        wait_for_same_request: "wait_for_same_request";
+        quarantine_then_prepare: "quarantine_then_prepare";
+        cleanup_quarantine_then_prepare: "cleanup_quarantine_then_prepare";
+        refuse_conflict: "refuse_conflict";
+    }>;
+    reason: z.ZodEnum<{
+        projection_absent: "projection_absent";
+        projection_exact_match: "projection_exact_match";
+        projection_staging_same_request: "projection_staging_same_request";
+        projection_staging_conflict: "projection_staging_conflict";
+        projection_stale: "projection_stale";
+        projection_quarantined: "projection_quarantined";
+        projection_invalid: "projection_invalid";
+        projection_interrupted: "projection_interrupted";
+        projection_conflicting: "projection_conflicting";
+    }>;
+    selection_allowed: z.ZodBoolean;
+    mutation_required: z.ZodBoolean;
+    selected_manifest_digest: z.ZodOptional<z.ZodString>;
+    next_actions: z.ZodArray<z.ZodEnum<{
+        prepare_projection_staging: "prepare_projection_staging";
+        reuse_projection: "reuse_projection";
+        retry_after_active_request: "retry_after_active_request";
+        quarantine_observed_projection: "quarantine_observed_projection";
+        cleanup_quarantined_projection: "cleanup_quarantined_projection";
+        stop_and_report_conflict: "stop_and_report_conflict";
+    }>>;
+}, z.core.$strip>>;
+type NativeWslProjectionPlan_v1 = z.infer<typeof NativeWslProjectionPlan_v1>;
+declare function planNativeWslProjection(requestInput: NativeWslProjectionRequest_v1, observationInput: NativeWslProjectionInventoryObservation_v1): NativeWslProjectionPlan_v1;
+
+type CommandAction = "source_root" | "source_remote" | "source_head" | "source_object_exists" | "source_object_type" | "source_status" | "clone_nonlocal" | "fetch_exact_object" | "verify_projected_object" | "checkout_exact_object" | "remove_projection_remote" | "list_projection_branches" | "remove_projection_branch" | "verify_projection_head" | "verify_projection_status";
+interface NativeWslProjectionCommandEvidence {
+    action: CommandAction;
+    argvHash: string;
+    outcome: "passed" | "failed";
+    exitCode: number | null;
+    stdoutHash: string;
+    stderrHash: string;
+    durationMs: number;
+}
+interface NativeWslProjectionSuccess {
+    ok: true;
+    outcome: "prepared" | "reused";
+    manifest: NativeWslProjectionManifest_v1;
+    receipt: NativeWslProjectionReceipt_v1;
+    sourceObservation: NativeWslSourceObservation_v1;
+    selection: NativeWslProjectionSelection_v1;
+    broker: GitWorktreeBroker;
+    commandEvidence: NativeWslProjectionCommandEvidence[];
+    recoveredReason?: NativeWslProjectionReasonCode;
+}
+interface NativeWslProjectionFailure {
+    ok: false;
+    outcome: "rejected" | "quarantined";
+    reasonCode: Exclude<NativeWslProjectionReasonCode, "projection_prepared" | "projection_reused">;
+    receipt: NativeWslProjectionReceipt_v1;
+    sourceObservation?: NativeWslSourceObservation_v1;
+    commandEvidence: NativeWslProjectionCommandEvidence[];
+}
+type NativeWslProjectionResult = NativeWslProjectionSuccess | NativeWslProjectionFailure;
+type NativeWslProjectionLifecycleState = "absent" | "preparing" | "ready" | "ready_unselected" | "stale" | "invalid" | "conflicting";
+interface NativeWslProjectionQuarantineSummary {
+    count: number;
+    entryDigests: string[];
+    truncated: boolean;
+}
+interface NativeWslProjectionInspection {
+    state: NativeWslProjectionLifecycleState;
+    projectionId: string;
+    requestDigest: string;
+    manifestDigest?: string;
+    selectionDigest?: string;
+    mappingDigest?: string;
+    sourceObservationDigest?: string;
+    activeWorktreeCount: number;
+    quarantine: {
+        repository: NativeWslProjectionQuarantineSummary;
+        allocation: NativeWslProjectionQuarantineSummary;
+    };
+    commandEvidence: NativeWslProjectionCommandEvidence[];
+}
+type NativeWslProjectionCleanupReason = "cleanup_complete" | "projection_absent" | "active_worktrees" | "concurrent_request" | "state_quarantined" | "cleanup_failed";
+interface NativeWslProjectionCleanupResult {
+    outcome: "cleaned" | "absent" | "refused" | "quarantined" | "failed";
+    reasonCode: NativeWslProjectionCleanupReason;
+    projectionId: string;
+    requestDigest: string;
+    removed: {
+        repository: boolean;
+        allocation: boolean;
+        quarantineEntries: number;
+    };
+    remainingQuarantine: number;
+}
+
+interface WorkerSessionStatusResult {
+    workerSession: WorkerSessionRecord | null;
+    adapter: BoundedWorkerAdapterStatus | null;
+    pathMapping: null | {
+        state: "bound" | "invalid";
+        kind?: "native_wsl_projection" | "native_linux";
+        mappingDigest?: string;
+    };
+}
+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<{
@@ -4373,17 +5984,20 @@ declare const AttemptPrepareRequestJsonSchema: z.core.ZodStandardJSONSchemaPaylo
         executionRoot: z.ZodString;
         exposedEnvironmentKeys: z.ZodArray<z.ZodString>;
         createdAt: z.ZodString;
+        projection: z.ZodOptional<z.ZodObject<{
+            selectionDigest: z.ZodString;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
     attempt: z.ZodObject<{
+        broker: z.ZodOptional<z.ZodObject<{
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
         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;
@@ -4482,6 +6096,308 @@ interface AttemptPreparationHandler {
 /** Top-level lifecycle seam. Every request owns and closes its SQLite connection. */
 declare function createAttemptLifecycleHandlers(): AttemptLifecycleHandlers & AttemptPreparationHandler;
 
+declare const NativeWslProjectionPrepareRequestSchema: z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+    mutation: z.ZodObject<{
+        authorized: z.ZodLiteral<true>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const NativeWslProjectionStatusRequestSchema: z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+declare const NativeWslProjectionCleanupRequestSchema: z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+    mutation: z.ZodObject<{
+        authorized: z.ZodLiteral<true>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    includeQuarantine: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const NativeWslProjectionPrepareRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+    mutation: z.ZodObject<{
+        authorized: z.ZodLiteral<true>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>>;
+declare const NativeWslProjectionStatusRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>>;
+declare const NativeWslProjectionCleanupRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+    mutation: z.ZodObject<{
+        authorized: z.ZodLiteral<true>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    includeQuarantine: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>>;
+declare const NativeWslProjectionQuarantineRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    request: z.ZodPreprocess<z.ZodObject<{
+        request_digest: z.ZodString;
+        schema_version: z.ZodLiteral<"1.0.0">;
+        request_id: z.ZodString;
+        repository: z.ZodPreprocess<z.ZodObject<{
+            id: z.ZodString;
+            expected_remote_hash: z.ZodString;
+        }, z.core.$strip>>;
+        source: z.ZodPreprocess<z.ZodObject<{
+            windows_runtime: z.ZodString;
+            windows_repository_path: z.ZodString;
+            wsl_distribution: z.ZodString;
+            wsl_git_runtime: z.ZodString;
+            wsl_repository_path: z.ZodString;
+            head_policy: z.ZodEnum<{
+                observe: "observe";
+                require_base: "require_base";
+            }>;
+            dirty_policy: z.ZodEnum<{
+                require_clean: "require_clean";
+                committed_base_only: "committed_base_only";
+            }>;
+        }, z.core.$strip>>;
+        native: z.ZodPreprocess<z.ZodObject<{
+            host_id: z.ZodString;
+            git_runtime: z.ZodString;
+            projection_root: z.ZodString;
+            worktree_root: z.ZodString;
+        }, z.core.$strip>>;
+        base_sha: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>>;
+type NativeWslProjectionPrepareRequest = z.infer<typeof NativeWslProjectionPrepareRequestSchema>;
+type NativeWslProjectionStatusRequest = z.infer<typeof NativeWslProjectionStatusRequestSchema>;
+type NativeWslProjectionCleanupRequest = z.infer<typeof NativeWslProjectionCleanupRequestSchema>;
+type NativeWslProjectionPublicNextAction = "prepare_projection" | "retry_projection_status" | "prepare_attempt" | "inspect_quarantine" | "cleanup_projection" | "remove_active_worktrees" | "correct_projection_request";
+interface NativeWslProjectionPrepareResult {
+    schemaVersion: "1.0.0";
+    operation: "agent-work.projection.prepare";
+    outcome: NativeWslProjectionResult["outcome"];
+    state: "ready" | "rejected" | "quarantined";
+    reasonCode: NativeWslProjectionReasonCode;
+    projectionId: string;
+    requestDigest: string;
+    selectionDigest?: string;
+    manifestDigest?: string;
+    mappingDigest?: string;
+    sourceObservationDigest?: string;
+    commandEvidence: NativeWslProjectionCommandEvidence[];
+    nextActions: NativeWslProjectionPublicNextAction[];
+}
+interface NativeWslProjectionStatusResult extends Omit<NativeWslProjectionInspection, "commandEvidence"> {
+    schemaVersion: "1.0.0";
+    operation: "agent-work.projection.status";
+    commandEvidence: NativeWslProjectionCommandEvidence[];
+    nextActions: NativeWslProjectionPublicNextAction[];
+}
+interface NativeWslProjectionQuarantineResult {
+    schemaVersion: "1.0.0";
+    operation: "agent-work.projection.quarantine.inspect";
+    projectionId: string;
+    requestDigest: string;
+    state: NativeWslProjectionInspection["state"];
+    quarantine: NativeWslProjectionInspection["quarantine"];
+    nextActions: NativeWslProjectionPublicNextAction[];
+}
+interface NativeWslProjectionCleanupPublicResult extends NativeWslProjectionCleanupResult {
+    schemaVersion: "1.0.0";
+    operation: "agent-work.projection.cleanup";
+    nextActions: NativeWslProjectionPublicNextAction[];
+}
+interface ProjectionLifecycleEngine {
+    prepare(request: NativeWslProjectionPrepareRequest["request"]): Promise<NativeWslProjectionResult>;
+    inspect(request: NativeWslProjectionStatusRequest["request"]): Promise<NativeWslProjectionInspection>;
+    cleanup(request: NativeWslProjectionCleanupRequest["request"], includeQuarantine?: boolean): Promise<NativeWslProjectionCleanupResult>;
+}
+interface NativeWslProjectionLifecycleHandlers {
+    prepare(request: unknown): Promise<AgentWorkHandlerResult<NativeWslProjectionPrepareResult>>;
+    status(request: unknown): Promise<AgentWorkHandlerResult<NativeWslProjectionStatusResult>>;
+    cleanup(request: unknown): Promise<AgentWorkHandlerResult<NativeWslProjectionCleanupPublicResult>>;
+    quarantine(request: unknown): Promise<AgentWorkHandlerResult<NativeWslProjectionQuarantineResult>>;
+}
+/** One bounded application seam shared by the projection CLI and MCP adapters. */
+declare function createNativeWslProjectionLifecycleHandlers(engine?: ProjectionLifecycleEngine): NativeWslProjectionLifecycleHandlers;
+
 declare const AttemptWorkerAttachRequestJsonSchema: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
     runtime: z.ZodObject<{
         databasePath: z.ZodString;
@@ -4525,12 +6441,97 @@ declare const AttemptWorkerAttachRequestJsonSchema: z.core.ZodStandardJSONSchema
             paths: z.ZodObject<{
                 project_root: z.ZodString;
                 execution_root: z.ZodString;
+                allocation_root: z.ZodOptional<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>>;
+            path_mappings: z.ZodArray<z.ZodUnion<readonly [z.ZodPreprocess<z.ZodObject<{
+                mapping_digest: z.ZodString;
+                schema_version: z.ZodLiteral<"1.0.0">;
+                projection_id: z.ZodString;
+                repository_id: z.ZodString;
+                base_sha: z.ZodString;
+                native_host_id: z.ZodString;
+                request_digest: z.ZodString;
+                projection_digest: z.ZodString;
+                projection_mapping_digest: z.ZodString;
+                roots: z.ZodPreprocess<z.ZodObject<{
+                    windows_source: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"declared">;
+                    }, z.core.$strip>>;
+                    wsl_source: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"git_observed">;
+                        observation_digest: z.ZodString;
+                    }, z.core.$strip>>;
+                    native_repository: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    native_worktree: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>, z.ZodPreprocess<z.ZodObject<{
+                mapping_digest: z.ZodString;
+                schema_version: z.ZodLiteral<"1.0.0">;
+                mapping_kind: z.ZodLiteral<"native_linux">;
+                repository_id: z.ZodString;
+                base_sha: z.ZodString;
+                native_host_id: z.ZodString;
+                git_runtime: z.ZodString;
+                roots: z.ZodPreprocess<z.ZodObject<{
+                    native_repository: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    native_allocation_root: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                    native_worktree: z.ZodPreprocess<z.ZodObject<{
+                        runtime_id: z.ZodString;
+                        path: z.ZodString;
+                        verification: z.ZodLiteral<"directory_identity">;
+                        directory_identity: z.ZodPreprocess<z.ZodObject<{
+                            device: z.ZodString;
+                            inode: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>]>>;
             exposed_environment_keys: z.ZodArray<z.ZodString>;
             created_at: z.ZodString;
         }, z.core.$strict>;
@@ -4761,7 +6762,7 @@ interface AttemptAcceptanceStatusResult {
     };
 }
 
-type FanoutServiceStore = AgentWorkFanoutStore & WorkspaceLifecycleStore & AttemptReceiptStore & AttemptVerificationStore;
+type FanoutServiceStore = AgentWorkFanoutStore & WorkspaceLifecycleStore & LaunchEnvelopeBindingStore & WorkerSessionStore & AttemptReceiptStore & AttemptVerificationStore;
 interface CreateAgentWorkFanoutInput {
     runId: string;
     expectedRunRevision: number;
@@ -5868,8 +7869,8 @@ interface GateExecutionServiceResult {
     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);
+    readonly code: "GATE_EXECUTION_FAILED" | "GATE_RESULT_LIMIT_EXCEEDED" | "GATE_SELECTION_NOT_FOUND";
+    constructor(code: "GATE_EXECUTION_FAILED" | "GATE_RESULT_LIMIT_EXCEEDED" | "GATE_SELECTION_NOT_FOUND", message: string);
 }
 /** One bounded transport-neutral owner for canonical CLI and MCP gate execution. */
 declare class GateExecutionService {
@@ -6072,6 +8073,45 @@ declare class MergeApplicationService {
     }>;
 }
 
+type PlanArtifactSource = "explicit" | "repository-root" | "profile-runner";
+interface PlanArtifactIdentity {
+    contract: "plan-artifact-identity-v1";
+    kind: "execution-plan";
+    schema: "lexrunner.execution-plan";
+    schemaVersion: string;
+    digest: string;
+    target: string;
+    itemCount: number;
+}
+interface ResolvedPlanArtifact {
+    plan: Plan;
+    identity: PlanArtifactIdentity;
+    source: PlanArtifactSource;
+    /** Adapter-only location. It is deliberately excluded from the public identity. */
+    filePath: string;
+}
+type PlanArtifactFailureCode = "PLAN_REFERENCE_INVALID" | "PLAN_NOT_FOUND" | "PLAN_UNREADABLE" | "PLAN_ARTIFACT_LIMIT_EXCEEDED";
+declare class PlanArtifactServiceError extends Error {
+    readonly code: PlanArtifactFailureCode;
+    readonly source?: PlanArtifactSource | undefined;
+    constructor(code: PlanArtifactFailureCode, message: string, source?: PlanArtifactSource | undefined);
+}
+interface ResolvePlanArtifactInput {
+    planFile?: string;
+    workingDir?: string;
+    profileDir?: string;
+}
+/**
+ * Resolve one immutable integration plan without creating mutable "active plan" state.
+ *
+ * Precedence is explicit reference, repository-root plan.json, then the legacy
+ * profile runner plan. An explicit reference is authoritative: a bad explicit
+ * path never falls through to another plan.
+ */
+declare class PlanArtifactService {
+    resolve(input?: ResolvePlanArtifactInput): ResolvedPlanArtifact;
+}
+
 /**
  * Environmental Hostility Scoring
  *
@@ -6461,4 +8501,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 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 };
+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 };