@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,16 +1,12 @@
-import { type ExecutionObserver } from "../protocol/execution-observation.js";
-import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } 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";
-import { type MutationResult } from "./mutation.js";
-import type { DeliveryExecutionInput, Review } from "./contract-forwarding.js";
 import { z } from "zod";
-type DeliveryResult = MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
-type ReviewResult = MutationResult<Review>;
-type AuditResult = MutationResult<AuditReport>;
+import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCommand } from "../akuma/request-wire.js";
+import type { ActorId } from "../core/facts/types.js";
+import { type ExecutionObserver } from "../protocol/execution-observation.js";
+type DeliveryResult = import("./contract-outcomes.js").DeliverOutcome;
+type ReviewResult = import("./contract-outcomes.js").ReviewOutcome;
+type AuditResult = import("./contract-outcomes.js").AuditOutcome;
 type ContractResult = DeliveryResult | ReviewResult | AuditResult;
-type ContractRequester = NonNullable<DeliveryExecutionInput["actor"]>;
+type ContractRequester = ActorId;
 declare const auditRequestSchema: z.ZodPipe<z.ZodObject<{
     repoRoot: z.ZodString;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
@@ -88,142 +84,292 @@ type ContractRequestFor<Action extends ContractRequest["action"]> = Extract<Cont
 declare const materializedHandoffReferenceSchema: z.ZodObject<{
     kind: z.ZodLiteral<"integration-conflict-materialized">;
     targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    conflictPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    workspace: z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        path: z.ZodString;
+    }, z.core.$strict>;
     handoffBase: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
     recovery: z.ZodObject<{
         materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
         deliver: z.ZodLiteral<"deliver --include-dirty">;
         staging: z.ZodLiteral<"not-required">;
     }, z.core.$strict>;
-    conflictPaths: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<readonly string[], string[]>>;
-    workspace: z.ZodObject<{
-        kind: z.ZodLiteral<"worktree">;
-        path: z.ZodString;
-    }, z.core.$strict>;
 }, z.core.$strict>;
 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.ZodType<Readonly<{
-        candidate: Readonly<{
-            kind: "blocked";
-            refusal: import("./contract.js").DeliveryPreparationRefusal;
-        }> | Readonly<{
-            kind: "ready";
-            workspace: Readonly<{
-                kind: "worktree";
-                path: string;
-            }>;
-            identity: import("../core/facts/types.js").DeliverData;
-            scope: Readonly<{
-                filesChanged: number;
-                insertions: number;
-                deletions: number;
-                paths?: readonly string[];
-            }>;
-            diff?: string;
-        }>;
-        verification: Readonly<{
-            kind: "not-run";
-        }> | Readonly<{
-            kind: "satisfied";
-            passed: number;
-            total: number;
-            summary?: string;
-        }> | Readonly<{
-            kind: "unsatisfied";
-            passed: number;
-            total: number;
-            summary?: string;
-        }> | Readonly<{
-            kind: "stopped";
-            stop: import("./contract.js").VerificationStop;
-        }>;
-        target: Readonly<{
-            kind: "not-observed";
-        }> | import("../git/target-placement.js").AuditTargetAnswer;
-        delivery?: Readonly<{
-            changeId: import("../core/facts/types.js").ChangeId;
-            relation: "identical" | "differs";
-            verification: Readonly<{
-                kind: "undeclared" | "unrecorded";
-            }> | Readonly<{
-                kind: "recorded";
-                verdict: "satisfied" | "unsatisfied";
-                fact: import("../core/facts/types.js").EntryUlid;
-            }>;
-        }>;
-    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
-        candidate: Readonly<{
-            kind: "blocked";
-            refusal: import("./contract.js").DeliveryPreparationRefusal;
-        }> | Readonly<{
-            kind: "ready";
-            workspace: Readonly<{
-                kind: "worktree";
-                path: string;
+    report: z.ZodObject<{
+        candidate: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"blocked">;
+            refusal: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"target-missing">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"worktree-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.ZodReadonly<z.ZodArray<z.ZodString>>;
+                unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                submodules: z.ZodReadonly<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.ZodReadonly<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<{
+                    "not-based-on-target": "not-based-on-target";
+                    "unrelated-histories": "unrelated-histories";
+                    conflict: "conflict";
+                }>;
+                targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+                conflictPaths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>, z.ZodTransform<{
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+            } & {
+                conflictPaths?: readonly string[];
+            }, {
+                kind: "integration-failed";
+                contractId: import("../core/facts/types.js").ContractId;
+                reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+                targetHead: import("../core/facts/types.js").SnapshotId;
+                conflictPaths?: readonly 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.ZodLiteral<"untracked">;
+                paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, 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.ZodObject<{
+                filesChanged: z.ZodNumber;
+                insertions: z.ZodNumber;
+                deletions: z.ZodNumber;
+                paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>;
+            diff: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        verification: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"not-run">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"undeclared">;
+        }, 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.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.core.$strict>, z.ZodObject<{
+                retry: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        exhausted: "exhausted";
+                        collision: "collision";
+                    }>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"publication-failed">;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+                failure: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    "unknown-exit": "unknown-exit";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+                failure: z.ZodEnum<{
+                    "spawn-error": "spawn-error";
+                    "candidate-unavailable": "candidate-unavailable";
+                }>;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+                failure: z.ZodLiteral<"environment-failure">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+                failure: z.ZodLiteral<"environment-failure">;
+                name: z.ZodString;
+                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<{
+                    stdout: z.ZodOptional<z.ZodString>;
+                    stderr: z.ZodOptional<z.ZodString>;
+                    truncated: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodLiteral<"timeout">;
+                }, z.core.$strict>, z.ZodObject<{
+                    stdout: z.ZodOptional<z.ZodString>;
+                    stderr: z.ZodOptional<z.ZodString>;
+                    truncated: z.ZodOptional<z.ZodBoolean>;
+                    kind: z.ZodLiteral<"unknown-exit">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"spawn-error">;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>]>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
             }>;
-            identity: import("../core/facts/types.js").DeliverData;
-            scope: Readonly<{
-                filesChanged: number;
-                insertions: number;
-                deletions: number;
-                paths?: readonly string[];
+            passed: z.ZodNumber;
+            total: z.ZodNumber;
+            summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+            verdict: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
             }>;
-            diff?: string;
-        }>;
-        verification: Readonly<{
-            kind: "not-run";
-        }> | Readonly<{
-            kind: "satisfied";
-            passed: number;
-            total: number;
-            summary?: string;
-        }> | Readonly<{
-            kind: "unsatisfied";
-            passed: number;
-            total: number;
-            summary?: string;
-        }> | Readonly<{
-            kind: "stopped";
-            stop: import("./contract.js").VerificationStop;
-        }>;
-        target: Readonly<{
-            kind: "not-observed";
-        }> | import("../git/target-placement.js").AuditTargetAnswer;
-        delivery?: Readonly<{
-            changeId: import("../core/facts/types.js").ChangeId;
-            relation: "identical" | "differs";
-            verification: Readonly<{
-                kind: "undeclared" | "unrecorded";
-            }> | Readonly<{
-                kind: "recorded";
-                verdict: "satisfied" | "unsatisfied";
-                fact: import("../core/facts/types.js").EntryUlid;
+            summary: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"reused">;
+        }, z.core.$strict>]>;
+        target: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"not-observed">;
+        }, z.core.$strict>, z.ZodUnion<readonly [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.ZodLiteral<"untracked">;
+                paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"failed">;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>]>]>;
+        targetLag: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unknown">;
+            subject: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"worktree">;
+                path: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"counted">;
+            behind: z.ZodNumber;
+            subject: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"worktree">;
+                path: z.ZodString;
+            }, z.core.$strict>>;
+        }, 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";
             }>;
-        }>;
-    }>, unknown>>;
+            verification: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    undeclared: "undeclared";
+                    unrecorded: "unrecorded";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"recorded">;
+                verdict: z.ZodEnum<{
+                    satisfied: "satisfied";
+                    unsatisfied: "unsatisfied";
+                }>;
+                fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
 }, 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<"materialized-handoff">;
-    repoRoot: z.ZodString;
-    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
     targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    conflictPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    workspace: z.ZodObject<{
+        kind: z.ZodLiteral<"worktree">;
+        path: z.ZodString;
+    }, z.core.$strict>;
     handoffBase: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
     recovery: z.ZodObject<{
         materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
         deliver: z.ZodLiteral<"deliver --include-dirty">;
         staging: z.ZodLiteral<"not-required">;
     }, z.core.$strict>;
-    conflictPaths: z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<readonly string[], string[]>>;
-    workspace: z.ZodObject<{
-        kind: z.ZodLiteral<"worktree">;
-        path: z.ZodString;
-    }, z.core.$strict>;
+    kind: z.ZodLiteral<"materialized-handoff">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"accepted-reference">;
     repoRoot: z.ZodString;
@@ -237,26 +383,17 @@ export type ContractRequestPort = Readonly<{
         requester: ContractRequester;
         signal: AbortSignal;
         observe?: ExecutionObserver;
-    }>): Promise<Readonly<{
-        result: AuditResult;
-        auditReport?: AuditReport;
-    }>>;
+    }>): Promise<AuditResult>;
     deliver(input: DeliverRequest & Readonly<{
         requester: ContractRequester;
         signal: AbortSignal;
         observe?: ExecutionObserver;
-    }>): Promise<Readonly<{
-        result: DeliveryResult;
-        deliveryFactId?: string;
-    }>>;
+    }>): Promise<DeliveryResult>;
     review(input: ReviewRequest & Readonly<{
         requester: ContractRequester;
         signal: AbortSignal;
         observe?: ExecutionObserver;
-    }>): Promise<Readonly<{
-        result: ReviewResult;
-        reviewFactId?: string;
-    }>>;
+    }>): Promise<ReviewResult>;
 }>;
 export declare function contractRequestProtocol(action: ContractRequest["action"]): RequestProtocol<ContractRequest, ContractResult, ContractReference>;
 export declare function contractRequestCommand(action: ContractRequest["action"], port: ContractRequestPort): ServiceRequestCommand<ContractRequest, ContractResult, ContractService, ContractReference>;
@@ -268,5 +405,9 @@ export declare function requestForwardedContractLive<Action extends ContractRequ
     signal?: AbortSignal;
     observe?: ExecutionObserver;
 }>): Promise<ContractResultFor<Action>>;
-export { executeLocalDelivery, executeLocalReview, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./contract-forwarding.js";
-export type { AttestationVerdict, DeliveryExecutionInput, Review, ReviewExecutionInput, } from "./contract-forwarding.js";
+/** Map durable request disposition without reconstructing an expired owner answer. */
+export declare function mapForwardedContractFailure(error: unknown, request: ContractRequest): {
+    kind: "returned";
+    result: import("./outcome.js").ProjectedOutcome<"deliver" | "review" | "audit", unknown, unknown>;
+};
+export {};