@astrosheep/keiyaku 4.5.7 → 4.5.8

package/build/src/library/contract-operations.d.ts

@@ -1,77 +1,1054 @@
-import { type RepositoryScope } from "../protocol/operations.js";
-import { type IntegrationConflictMaterialized } from "../protocol/deliver.js";
-import { type ReviewValue } from "../protocol/review.js";
-import { type ContinuationReport } from "./continuation.js";
-import { type MutationResult } from "./mutation.js";
-import { type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
-import { actorOption } from "./input.js";
-import { type WorktreeHooks } from "./configuration.js";
-import { Repo } from "./repo.js";
-import { type ContractId } from "../core/facts/types.js";
-import type { UpstreamRequestOutcome } from "../akuma/requests.js";
+import { type ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
+import type { AuditReport } from "../protocol/audit.js";
+import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
 import type { DeliveryValue } from "./delivery.js";
-export type DeliveryExecutionInput = Readonly<{
-    scope: RepositoryScope;
-    contractId: ContractId;
-    actor?: ReturnType<typeof actorOption>["actor"];
-    message?: string;
+import type { MutationResult } from "./mutation.js";
+import type { Review } from "./contract-forwarding.js";
+import { z } from "zod";
+type DeliveryResult = MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
+type ReviewResult = MutationResult<Review>;
+type AuditResult = MutationResult<AuditReport>;
+type ContractResult = DeliveryResult | ReviewResult | AuditResult;
+declare const auditRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    includeDirty: z.ZodBoolean;
+    showDiff: z.ZodBoolean;
+    requireBranchesToBeUpToDate: z.ZodBoolean;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    showDiff: boolean;
     requireBranchesToBeUpToDate: boolean;
+    action: "contract.audit";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    showDiff: boolean;
+    requireBranchesToBeUpToDate: boolean;
+}>>;
+declare const deliverRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    includeDirty: z.ZodBoolean;
+    materializeConflict: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
     includeDirty: boolean;
     materializeConflict: boolean;
-    signal?: AbortSignal;
-    hooks: WorktreeHooks;
+    message?: string | undefined;
+    action: "contract.deliver";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    message?: string | undefined;
+}>>;
+declare const reviewRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    verdict: z.ZodEnum<{
+        satisfied: "satisfied";
+        unsatisfied: "unsatisfied";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string | undefined;
+    action: "contract.review";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string | undefined;
+}>>;
+export type ContractRequest = z.infer<typeof auditRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
+type DeliverRequest = Extract<ContractRequest, {
+    action: "contract.deliver";
 }>;
-export type ReviewExecutionInput = Readonly<{
-    scope: RepositoryScope;
-    contractId: ContractId;
-    actor?: ReturnType<typeof actorOption>["actor"];
-    verdict: AttestationVerdict;
-    summary?: string;
-    hooks: WorktreeHooks;
+type ReviewRequest = Extract<ContractRequest, {
+    action: "contract.review";
 }>;
-export type AttestationVerdict = "satisfied" | "unsatisfied";
-export type Review = ReviewValue & Readonly<{
-    continuation?: ContinuationReport;
+type AuditRequest = Extract<ContractRequest, {
+    action: "contract.audit";
 }>;
-export type ForwardedMutationReceipt<Value> = Readonly<{
-    kind: "accepted";
-    result: MutationResult<Value>;
-}> | Readonly<{
-    kind: "refused";
-    refusal: KeiyakuRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: KeiyakuRetryReason;
+type ContractResultFor<Action extends ContractRequest["action"]> = Action extends "contract.deliver" ? DeliveryResult : Action extends "contract.review" ? ReviewResult : AuditResult;
+type ContractRequestFor<Action extends ContractRequest["action"]> = Extract<ContractRequest, {
+    action: Action;
 }>;
-export type ForwardedDeliveryReceipt = ForwardedMutationReceipt<DeliveryValue> | IntegrationConflictMaterialized;
-export type ForwardedReviewReceipt = ForwardedMutationReceipt<Review>;
-export declare function executeLocalDelivery(input: DeliveryExecutionInput): Promise<MutationResult<DeliveryValue> | IntegrationConflictMaterialized>;
-export declare function executeLocalReview(input: ReviewExecutionInput): Promise<MutationResult<Review>>;
-export declare function forwardedReceipt<Receipt>(outcome: UpstreamRequestOutcome, action: string): Receipt;
-export declare function requireForwarded(receipt: ForwardedDeliveryReceipt): MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
-export declare function requireForwarded(receipt: ForwardedReviewReceipt): MutationResult<Review>;
-export declare function executeForwardedDeliver(input: Readonly<{
-    repo: Repo;
-    contractId: string;
+declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"audit-report">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    report: z.ZodPipe<z.ZodObject<{
+        candidate: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"blocked">;
+            refusal: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    "worktree-missing": "worktree-missing";
+                    "target-missing": "target-missing";
+                }>;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"dirty-workspace">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                staged: z.ZodArray<z.ZodString>;
+                unstaged: z.ZodArray<z.ZodString>;
+                untracked: z.ZodArray<z.ZodString>;
+                submodules: z.ZodArray<z.ZodString>;
+                shortStat: z.ZodObject<{
+                    filesChanged: z.ZodNumber;
+                    insertions: z.ZodNumber;
+                    deletions: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"unmerged-paths">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                paths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>, z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+                kind: z.ZodLiteral<"integration-failed">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    "not-based-on-target": "not-based-on-target";
+                    "unrelated-histories": "unrelated-histories";
+                }>;
+                targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+                conflictPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                conflictPaths: string[];
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            }, {
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+                conflictPaths?: string[] | undefined;
+            }>>, z.ZodObject<{
+                kind: z.ZodLiteral<"integration-unsupported">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                requiredGit: z.ZodLiteral<"2.38">;
+            }, z.core.$strict>]>, z.ZodObject<{
+                kind: z.ZodLiteral<"merge-state-present">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                workspace: z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree">;
+                    path: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"checkout-not-followable">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                target: z.ZodString;
+                path: z.ZodString;
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    staged: "staged";
+                    untracked: "untracked";
+                }>;
+                paths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+            kind: z.ZodLiteral<"ready">;
+            workspace: z.ZodObject<{
+                kind: z.ZodLiteral<"worktree">;
+                path: z.ZodString;
+            }, z.core.$strict>;
+            identity: z.ZodObject<{
+                tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+                integration: z.ZodObject<{
+                    predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+                    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+                    changeId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+                }, z.core.$strict>;
+                method: z.ZodLiteral<"squash">;
+                policy: z.ZodObject<{
+                    requireBranchesToBeUpToDate: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            scope: z.ZodPipe<z.ZodObject<{
+                filesChanged: z.ZodNumber;
+                insertions: z.ZodNumber;
+                deletions: z.ZodNumber;
+                paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            }, {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+                paths?: string[] | undefined;
+            }>>;
+            diff: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            diff: string;
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        }, {
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+            diff?: string | undefined;
+        }>>]>;
+        verification: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"not-run">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"stopped">;
+            stop: z.ZodUnion<readonly [z.ZodObject<{
+                refusal: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        terminal: "terminal";
+                        "contract-missing": "contract-missing";
+                    }>;
+                    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+                    kind: z.ZodLiteral<"verification-declaration-invalid">;
+                    contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>;
+                }, z.core.$strict>, z.ZodTransform<{
+                    kind: "verification-declaration-invalid";
+                } | {
+                    contractId: import("../core/facts/types.js").ContractId;
+                    kind: "verification-declaration-invalid";
+                }, {
+                    kind: "verification-declaration-invalid";
+                    contractId?: import("../core/facts/types.js").ContractId | undefined;
+                }>>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                retry: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"exhausted">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"collision">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"publication-failed">;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    "unknown-exit": "unknown-exit";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodEnum<{
+                    "spawn-error": "spawn-error";
+                    "candidate-unavailable": "candidate-unavailable";
+                }>;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodLiteral<"environment-failure">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodLiteral<"environment-failure">;
+                command: z.ZodNumber;
+                detail: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"exit">;
+                    code: z.ZodNumber;
+                    stdout: z.ZodString;
+                    stderr: z.ZodString;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"timeout">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"spawn-error">;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unknown-exit">;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+            kind: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
+            }>;
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            summary: string;
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        }, {
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+            summary?: string | undefined;
+        }>>]>;
+        target: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"not-observed">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"placeable">;
+            ref: z.ZodString;
+            head: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"moved">;
+            ref: z.ZodString;
+            expected: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+            observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"refused">;
+            refusal: z.ZodObject<{
+                kind: z.ZodLiteral<"checkout-not-followable">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                target: z.ZodString;
+                path: z.ZodString;
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    staged: "staged";
+                    untracked: "untracked";
+                }>;
+                paths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>]>;
+        delivery: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+            relation: z.ZodEnum<{
+                identical: "identical";
+                differs: "differs";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        candidate: {
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            diff: string;
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            kind: "blocked";
+            refusal: {
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                conflictPaths: string[];
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                kind: "merge-state-present";
+                contractId: import("../core/facts/types.js").ContractId;
+                workspace: {
+                    kind: "worktree";
+                    path: string;
+                };
+            } | {
+                kind: "unmerged-paths";
+                contractId: import("../core/facts/types.js").ContractId;
+                paths: string[];
+            } | {
+                kind: "dirty-workspace";
+                contractId: import("../core/facts/types.js").ContractId;
+                staged: string[];
+                unstaged: string[];
+                untracked: string[];
+                submodules: string[];
+                shortStat: {
+                    filesChanged: number;
+                    insertions: number;
+                    deletions: number;
+                };
+            } | {
+                kind: "integration-unsupported";
+                contractId: import("../core/facts/types.js").ContractId;
+                requiredGit: "2.38";
+            } | {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            } | {
+                kind: "worktree-missing" | "target-missing";
+                contractId: import("../core/facts/types.js").ContractId;
+            };
+        };
+        verification: {
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            summary: string;
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            kind: "not-run";
+        } | {
+            kind: "stopped";
+            stop: {
+                refusal: {
+                    kind: "verification-declaration-invalid";
+                } | {
+                    contractId: import("../core/facts/types.js").ContractId;
+                    kind: "verification-declaration-invalid";
+                } | {
+                    kind: "terminal" | "contract-missing";
+                    contractId: import("../core/facts/types.js").ContractId;
+                };
+            } | {
+                retry: {
+                    kind: "exhausted";
+                } | {
+                    kind: "collision";
+                } | {
+                    kind: "publication-failed";
+                    diagnostic: string;
+                };
+            } | {
+                failure: "cancelled" | "unknown-exit";
+            } | {
+                failure: "spawn-error" | "candidate-unavailable";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                command: number;
+                detail: {
+                    kind: "exit";
+                    code: number;
+                    stdout: string;
+                    stderr: string;
+                    truncated: boolean;
+                } | {
+                    kind: "timeout";
+                } | {
+                    kind: "spawn-error";
+                    diagnostic: string;
+                } | {
+                    kind: "unknown-exit";
+                };
+            };
+        };
+        target: {
+            kind: "not-observed";
+        } | {
+            kind: "placeable";
+            ref: string;
+            head: import("../core/facts/types.js").SnapshotId;
+        } | {
+            kind: "moved";
+            ref: string;
+            expected: import("../core/facts/types.js").SnapshotId;
+            observed: import("../core/facts/types.js").SnapshotId | null;
+        } | {
+            kind: "refused";
+            refusal: {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            };
+        } | {
+            kind: "failed";
+            diagnostic: string;
+        };
+    } | {
+        delivery: {
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        };
+        candidate: {
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            diff: string;
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            kind: "blocked";
+            refusal: {
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                conflictPaths: string[];
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                kind: "merge-state-present";
+                contractId: import("../core/facts/types.js").ContractId;
+                workspace: {
+                    kind: "worktree";
+                    path: string;
+                };
+            } | {
+                kind: "unmerged-paths";
+                contractId: import("../core/facts/types.js").ContractId;
+                paths: string[];
+            } | {
+                kind: "dirty-workspace";
+                contractId: import("../core/facts/types.js").ContractId;
+                staged: string[];
+                unstaged: string[];
+                untracked: string[];
+                submodules: string[];
+                shortStat: {
+                    filesChanged: number;
+                    insertions: number;
+                    deletions: number;
+                };
+            } | {
+                kind: "integration-unsupported";
+                contractId: import("../core/facts/types.js").ContractId;
+                requiredGit: "2.38";
+            } | {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            } | {
+                kind: "worktree-missing" | "target-missing";
+                contractId: import("../core/facts/types.js").ContractId;
+            };
+        };
+        verification: {
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            summary: string;
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            kind: "not-run";
+        } | {
+            kind: "stopped";
+            stop: {
+                refusal: {
+                    kind: "verification-declaration-invalid";
+                } | {
+                    contractId: import("../core/facts/types.js").ContractId;
+                    kind: "verification-declaration-invalid";
+                } | {
+                    kind: "terminal" | "contract-missing";
+                    contractId: import("../core/facts/types.js").ContractId;
+                };
+            } | {
+                retry: {
+                    kind: "exhausted";
+                } | {
+                    kind: "collision";
+                } | {
+                    kind: "publication-failed";
+                    diagnostic: string;
+                };
+            } | {
+                failure: "cancelled" | "unknown-exit";
+            } | {
+                failure: "spawn-error" | "candidate-unavailable";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                command: number;
+                detail: {
+                    kind: "exit";
+                    code: number;
+                    stdout: string;
+                    stderr: string;
+                    truncated: boolean;
+                } | {
+                    kind: "timeout";
+                } | {
+                    kind: "spawn-error";
+                    diagnostic: string;
+                } | {
+                    kind: "unknown-exit";
+                };
+            };
+        };
+        target: {
+            kind: "not-observed";
+        } | {
+            kind: "placeable";
+            ref: string;
+            head: import("../core/facts/types.js").SnapshotId;
+        } | {
+            kind: "moved";
+            ref: string;
+            expected: import("../core/facts/types.js").SnapshotId;
+            observed: import("../core/facts/types.js").SnapshotId | null;
+        } | {
+            kind: "refused";
+            refusal: {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            };
+        } | {
+            kind: "failed";
+            diagnostic: string;
+        };
+    }, {
+        candidate: {
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            diff: string;
+            kind: "ready";
+            workspace: {
+                kind: "worktree";
+                path: string;
+            };
+            identity: {
+                tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+                integration: {
+                    predecessor: import("../core/facts/types.js").SnapshotId;
+                    snapshot: import("../core/facts/types.js").SnapshotId;
+                    changeId: import("../core/facts/types.js").ChangeId;
+                };
+                method: "squash";
+                policy: {
+                    requireBranchesToBeUpToDate: boolean;
+                };
+            };
+            scope: {
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            } | {
+                paths: string[];
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+            };
+        } | {
+            kind: "blocked";
+            refusal: {
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                conflictPaths: string[];
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "conflict" | "not-based-on-target" | "unrelated-histories";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } | {
+                kind: "merge-state-present";
+                contractId: import("../core/facts/types.js").ContractId;
+                workspace: {
+                    kind: "worktree";
+                    path: string;
+                };
+            } | {
+                kind: "unmerged-paths";
+                contractId: import("../core/facts/types.js").ContractId;
+                paths: string[];
+            } | {
+                kind: "dirty-workspace";
+                contractId: import("../core/facts/types.js").ContractId;
+                staged: string[];
+                unstaged: string[];
+                untracked: string[];
+                submodules: string[];
+                shortStat: {
+                    filesChanged: number;
+                    insertions: number;
+                    deletions: number;
+                };
+            } | {
+                kind: "integration-unsupported";
+                contractId: import("../core/facts/types.js").ContractId;
+                requiredGit: "2.38";
+            } | {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            } | {
+                kind: "worktree-missing" | "target-missing";
+                contractId: import("../core/facts/types.js").ContractId;
+            };
+        };
+        verification: {
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            summary: string;
+            kind: "satisfied" | "unsatisfied";
+            passed: number;
+            total: number;
+        } | {
+            kind: "not-run";
+        } | {
+            kind: "stopped";
+            stop: {
+                refusal: {
+                    kind: "verification-declaration-invalid";
+                } | {
+                    contractId: import("../core/facts/types.js").ContractId;
+                    kind: "verification-declaration-invalid";
+                } | {
+                    kind: "terminal" | "contract-missing";
+                    contractId: import("../core/facts/types.js").ContractId;
+                };
+            } | {
+                retry: {
+                    kind: "exhausted";
+                } | {
+                    kind: "collision";
+                } | {
+                    kind: "publication-failed";
+                    diagnostic: string;
+                };
+            } | {
+                failure: "cancelled" | "unknown-exit";
+            } | {
+                failure: "spawn-error" | "candidate-unavailable";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                diagnostic: string;
+            } | {
+                failure: "environment-failure";
+                command: number;
+                detail: {
+                    kind: "exit";
+                    code: number;
+                    stdout: string;
+                    stderr: string;
+                    truncated: boolean;
+                } | {
+                    kind: "timeout";
+                } | {
+                    kind: "spawn-error";
+                    diagnostic: string;
+                } | {
+                    kind: "unknown-exit";
+                };
+            };
+        };
+        target: {
+            kind: "not-observed";
+        } | {
+            kind: "placeable";
+            ref: string;
+            head: import("../core/facts/types.js").SnapshotId;
+        } | {
+            kind: "moved";
+            ref: string;
+            expected: import("../core/facts/types.js").SnapshotId;
+            observed: import("../core/facts/types.js").SnapshotId | null;
+        } | {
+            kind: "refused";
+            refusal: {
+                kind: "checkout-not-followable";
+                contractId: import("../core/facts/types.js").ContractId;
+                target: string;
+                path: string;
+                reason: "conflict" | "staged" | "untracked";
+                paths: string[];
+            };
+        } | {
+            kind: "failed";
+            diagnostic: string;
+        };
+        delivery?: {
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        } | undefined;
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"accepted-reference">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    deliveryFactId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"accepted-reference">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    reviewFactId: z.ZodString;
+}, z.core.$strict>]>;
+export type ContractService = z.infer<typeof contractServiceSchema>;
+export type ContractRequestPort = Readonly<{
+    audit(input: AuditRequest & Readonly<{
+        requester: string;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: AuditResult;
+        auditReport?: AuditReport;
+    }>>;
+    deliver(input: DeliverRequest & Readonly<{
+        requester: string;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: DeliveryResult;
+        deliveryFactId?: string;
+    }>>;
+    review(input: ReviewRequest & Readonly<{
+        requester: string;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: ReviewResult;
+        reviewFactId?: string;
+    }>>;
+}>;
+type ContractExecutionContext = Readonly<{
     requester: string;
-    message?: string;
-    includeDirty: boolean;
-    materializeConflict: boolean;
-    requireBranchesToBeUpToDate: boolean;
-    hooks: WorktreeHooks;
+    signal: AbortSignal;
+    upstream: ContractRequestPort;
+}>;
+export declare function contractRequestCommand(action: ContractRequest["action"]): RequestCommand<ContractRequest, ContractResult, ContractService, ContractService, ContractExecutionContext>;
+export declare function contractRequestCommands(): Readonly<Record<"contract.audit" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
+export declare function requestForwardedContractLive<Action extends ContractRequest["action"]>(input: Readonly<{
+    directory: string;
+    action: Action;
+    request: ContractRequestFor<Action>;
     signal?: AbortSignal;
-}>): Promise<Readonly<{
-    result: ForwardedDeliveryReceipt;
-    deliveryFactId?: string;
-}>>;
-export declare function executeForwardedReview(input: Readonly<{
-    repo: Repo;
-    contractId: string;
-    requester: string;
-    verdict: AttestationVerdict;
-    summary?: string;
-    hooks: WorktreeHooks;
-}>): Promise<Readonly<{
-    result: ForwardedReviewReceipt;
-    reviewFactId?: string;
-}>>;
+}>): Promise<ContractResultFor<Action>>;
+export { executeLocalDelivery, executeLocalReview, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./contract-forwarding.js";
+export type { AttestationVerdict, DeliveryExecutionInput, Review, ReviewExecutionInput, } from "./contract-forwarding.js";