@astrosheep/keiyaku 4.6.4 → 4.6.6

package/build/src/protocol/completion.d.ts

@@ -4,49 +4,27 @@ import type { GitRepository } from "../git/process.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type ContractCheckpoint, type ProtocolProgress, type ExecutionStop } from "./progress.js";
 import type { DocumentDerivation, PlacementStop, VerificationStop } from "./operations.js";
-declare const candidateCompletionSchema: z.ZodObject<{
-    integration: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
-    predecessor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
-    target: z.ZodOptional<z.ZodString>;
-    scope: z.ZodOptional<z.ZodObject<{
-        deletions: z.ZodNumber;
-        filesChanged: z.ZodNumber;
-        insertions: z.ZodNumber;
-    }, z.core.$strict>>;
-    verification: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodEnum<{
-            reused: "reused";
-            ran: "ran";
-        }>;
-        verdict: z.ZodEnum<{
-            satisfied: "satisfied";
-            unsatisfied: "unsatisfied";
-        }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type CandidateCompletion = z.infer<typeof candidateCompletionSchema>;
-export declare const completionEvidenceSchema: z.ZodObject<{
-    completion: z.ZodOptional<z.ZodObject<{
-        integration: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
-        predecessor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
-        target: z.ZodOptional<z.ZodString>;
-        scope: z.ZodOptional<z.ZodObject<{
-            deletions: z.ZodNumber;
-            filesChanged: z.ZodNumber;
-            insertions: z.ZodNumber;
-        }, z.core.$strict>>;
-        verification: z.ZodOptional<z.ZodObject<{
-            mode: z.ZodEnum<{
-                reused: "reused";
-                ran: "ran";
-            }>;
-            verdict: z.ZodEnum<{
-                satisfied: "satisfied";
-                unsatisfied: "unsatisfied";
-            }>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    verification: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+declare const verificationEvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    verdict: z.ZodEnum<{
+        satisfied: "satisfied";
+        unsatisfied: "unsatisfied";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"ran">;
+    entry: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>>;
+}, z.core.$strict>, z.ZodObject<{
+    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    verdict: z.ZodEnum<{
+        satisfied: "satisfied";
+        unsatisfied: "unsatisfied";
+    }>;
+    entry: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
+    summary: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"reused">;
+}, 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";
@@ -116,27 +94,123 @@ export declare const completionEvidenceSchema: z.ZodObject<{
             kind: z.ZodLiteral<"spawn-error">;
             diagnostic: z.ZodString;
         }, z.core.$strict>]>;
-    }, z.core.$strict>]>]>>;
-    verificationReuse: z.ZodOptional<z.ZodObject<{
-        entry: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
+    }, z.core.$strict>]>]>;
+}, z.core.$strict>], "kind">;
+export type VerificationEvidence = z.infer<typeof verificationEvidenceSchema>;
+declare const candidateCompletionSchema: z.ZodObject<{
+    integration: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    predecessor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
+    target: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodObject<{
+        deletions: z.ZodNumber;
+        filesChanged: z.ZodNumber;
+        insertions: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CandidateCompletion = z.infer<typeof candidateCompletionSchema>;
+export declare const completionEvidenceSchema: z.ZodObject<{
+    completion: z.ZodOptional<z.ZodObject<{
+        integration: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+        predecessor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>>;
+        target: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodObject<{
+            deletions: z.ZodNumber;
+            filesChanged: z.ZodNumber;
+            insertions: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    verification: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
         verdict: z.ZodEnum<{
             satisfied: "satisfied";
             unsatisfied: "unsatisfied";
         }>;
         summary: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    verificationSubject: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodEnum<{
-            reused: "reused";
-            ran: "ran";
-        }>;
+        kind: z.ZodLiteral<"ran">;
+        entry: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
         verdict: z.ZodEnum<{
             satisfied: "satisfied";
             unsatisfied: "unsatisfied";
         }>;
-        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
-    }, z.core.$strict>>;
-    verificationSummary: z.ZodOptional<z.ZodString>;
+        entry: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"reused">;
+    }, 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<ContractId, string>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"verification-declaration-invalid">;
+                contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<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>], "kind">>;
     placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         refusal: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{

package/build/src/protocol/completion.js

@@ -1,15 +1,23 @@
 import { z } from "zod";
-import { snapshotIdSchema, verdictSchema, verificationStopSchema, placementStopSchema } from "./operations.js";
-import { verificationReuseSchema } from "./intent.js";
+import { snapshotIdSchema, verdictSchema, verificationStopSchema, placementStopSchema, entryUlidSchema, } from "./operations.js";
 import { deliveryDiffScopeSchema, readDeliveryScope } from "../git/integration.js";
 import { currentVerifiedAttestation, verifyDelivery } from "./intent.js";
-import { admitPlacement, observeTargetPlacement } from "./placement.js";
+import { admitPlacement, observeTargetPlacement, observeIntegrationTargetMovement } from "./placement.js";
 import { reintegrateOperation } from "./reintegrate.js";
 import { contractCheckpoint, executionStop, isOperationalFailure, isOperationalStop, } from "./progress.js";
 import { placementStop, timestamp, unpackVerificationOutcome } from "./operations.js";
-import { VERIFIED } from "../verification/declaration.js";
 const MAX_REINTEGRATION_CYCLES = 3;
-const verdictProvenanceSchema = z.object({ mode: z.enum(["ran", "reused"]), verdict: verdictSchema }).strict();
+const verificationVerdictSchema = z.object({
+    snapshot: snapshotIdSchema,
+    verdict: verdictSchema,
+    entry: entryUlidSchema,
+    summary: z.string().optional(),
+});
+const verificationEvidenceSchema = z.discriminatedUnion("kind", [
+    verificationVerdictSchema.extend({ kind: z.literal("ran"), entry: entryUlidSchema.optional() }).strict(),
+    verificationVerdictSchema.extend({ kind: z.literal("reused") }).strict(),
+    z.object({ kind: z.literal("stopped"), stop: verificationStopSchema }).strict(),
+]);
 const candidateCompletionSchema = z
     .object({
     integration: snapshotIdSchema,
@@ -19,20 +27,12 @@ const candidateCompletionSchema = z
         .refine((value) => value.trim() !== "")
         .optional(),
     scope: deliveryDiffScopeSchema.omit({ paths: true }).optional(),
-    verification: verdictProvenanceSchema.optional(),
 })
     .strict();
-const verificationSubjectSchema = verdictProvenanceSchema.extend({ snapshot: snapshotIdSchema }).strict();
 export const completionEvidenceSchema = z
     .object({
     completion: candidateCompletionSchema.optional(),
-    verification: verificationStopSchema.optional(),
-    verificationReuse: verificationReuseSchema.optional(),
-    verificationSubject: verificationSubjectSchema.optional(),
-    verificationSummary: z
-        .string()
-        .refine((value) => value.trim() !== "")
-        .optional(),
+    verification: verificationEvidenceSchema.optional(),
     placement: placementStopSchema.optional(),
 })
     .strict();
@@ -53,18 +53,19 @@ async function verifyCurrentCandidate(input, cursor) {
     cursor.evidence = {};
     cursor.ran = undefined;
     input.progress.recordCandidate(state.id, cursor.evidence);
-    const current = currentVerifiedAttestation(state);
-    if (current !== undefined) {
-        cursor.evidence = {
-            verificationReuse: current,
-            verificationSubject: { snapshot, mode: "reused", verdict: current.verdict },
-        };
+    const declaration = input.deriveDocument(state).verification;
+    if (declaration.kind === "refused") {
+        cursor.evidence = { verification: { kind: "stopped", stop: { refusal: declaration.refusal } } };
         input.progress.recordCandidate(state.id, cursor.evidence);
         return;
     }
-    const declaration = input.deriveDocument(state).verification;
-    if (declaration.kind === "refused") {
-        cursor.evidence = { verification: { refusal: declaration.refusal } };
+    if (declaration.data === null)
+        return;
+    const current = currentVerifiedAttestation(state);
+    if (current?.verdict === "satisfied") {
+        cursor.evidence = {
+            verification: { kind: "reused", snapshot, ...current },
+        };
         input.progress.recordCandidate(state.id, cursor.evidence);
         return;
     }
@@ -78,7 +79,7 @@ async function verifyCurrentCandidate(input, cursor) {
         snapshot,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         progress: input.progress,
-        ...(declaration.data === null ? {} : { verification: declaration.data }),
+        verification: declaration.data,
     });
     if (result === null)
         return;
@@ -88,19 +89,22 @@ async function verifyCurrentCandidate(input, cursor) {
         input.progress.recordResidue(state.id, verified.admission);
         cursor.ran = verified.admission.facts.find((fact) => fact.kind === "attestation" && fact.data.gate === "verified")?.entry;
     }
-    const subject = verified.reuse !== undefined
-        ? { snapshot, mode: "reused", verdict: verified.reuse.verdict }
-        : verified.counts === undefined
-            ? undefined
-            : { snapshot, mode: "ran", verdict: verified.counts.verdict };
-    cursor.evidence = {
-        ...(verified.reuse === undefined ? {} : { verificationReuse: verified.reuse }),
-        ...(subject === undefined ? {} : { verificationSubject: subject }),
-        ...(verified.stop === undefined ? {} : { verification: verified.stop }),
-        ...(verified.counts?.verdict !== "unsatisfied" || verified.counts.summary === undefined
-            ? {}
-            : { verificationSummary: verified.counts.summary }),
-    };
+    if (verified.reuse !== undefined)
+        cursor.ran = verified.reuse.entry;
+    const verification = verified.stop !== undefined
+        ? { kind: "stopped", stop: verified.stop }
+        : verified.reuse !== undefined
+            ? { kind: "reused", snapshot, ...verified.reuse }
+            : verified.counts === undefined
+                ? undefined
+                : {
+                    kind: "ran",
+                    snapshot,
+                    verdict: verified.counts.verdict,
+                    ...(cursor.ran === undefined ? {} : { entry: cursor.ran }),
+                    ...(verified.counts.verdict === "unsatisfied" ? { summary: verified.counts.summary } : {}),
+                };
+    cursor.evidence = verification === undefined ? {} : { verification };
     input.progress.recordCandidate(state.id, cursor.evidence);
 }
 async function observeCandidateTarget(input, cursor) {
@@ -139,39 +143,27 @@ async function completedResult(input, cursor) {
         ...(predecessor === undefined || target === undefined ? {} : { predecessor, target }),
     };
     input.progress.recordCompletion(state.id, cursor.completion);
-    // Never attach a superseded run's verdict to the final integration.
-    const current = currentVerifiedAttestation(state);
+    const declaration = input.deriveDocument(state).verification;
+    const current = declaration.data == null ? undefined : currentVerifiedAttestation(state);
     const verification = current === undefined
         ? undefined
-        : {
-            mode: cursor.ran === current.entry ? "ran" : "reused",
-            verdict: current.verdict,
-        };
-    cursor.completion = { ...cursor.completion, ...(verification === undefined ? {} : { verification }) };
-    input.progress.recordCompletion(state.id, cursor.completion);
+        : { kind: cursor.ran === current.entry ? "ran" : "reused", snapshot: integration, ...current };
+    cursor.evidence = verification === undefined ? {} : { verification };
+    input.progress.recordCandidate(state.id, { ...cursor.evidence, completion: cursor.completion });
     const scope = predecessor === undefined ? undefined : await readDeliveryScope(input.repository, predecessor, integration, false);
-    const { verificationSummary: _oldSummary, verificationReuse: _oldReuse, verificationSubject: _oldSubject, ...evidence } = cursor.evidence;
     const completion = {
         integration,
         ...(predecessor === undefined || target === undefined ? {} : { predecessor, target }),
         ...(scope === undefined
             ? {}
             : { scope: { filesChanged: scope.filesChanged, insertions: scope.insertions, deletions: scope.deletions } }),
-        ...(verification === undefined ? {} : { verification }),
     };
     cursor.completion = completion;
     input.progress.recordCompletion(state.id, completion);
     return {
         kind: "completed",
         checkpoint: cursor.checkpoint,
-        evidence: {
-            ...evidence,
-            completion,
-            ...(current === undefined || verification?.mode !== "reused" ? {} : { verificationReuse: current }),
-            ...(current?.verdict !== "unsatisfied" || current.summary === undefined
-                ? {}
-                : { verificationSummary: current.summary }),
-        },
+        evidence: { ...cursor.evidence, completion },
     };
 }
 function stoppedResult(cursor, stop) {
@@ -226,34 +218,34 @@ async function placeCurrentCandidate(input, cursor) {
     }
     return result;
 }
-/** Verification blocks completion only when the Contract selected the verified gate; placement owns gate eligibility. */
-function verificationBlocks(state) {
-    return state.terms.gates.includes(VERIFIED);
-}
 async function verifyCandidateReadiness(input, cursor) {
     const observedPlacement = await observeCandidateTarget(input, cursor);
     await verifyCurrentCandidate(input, cursor);
-    const verification = cursor.evidence.verification;
-    const blocking = verification !== undefined && verificationBlocks(cursor.checkpoint.state);
-    if (blocking || observedPlacement !== undefined) {
+    const stop = cursor.evidence.verification?.kind === "stopped" ? cursor.evidence.verification.stop : observedPlacement;
+    if (stop !== undefined) {
         return {
             kind: "stopped",
             checkpoint: cursor.checkpoint,
             evidence: { ...cursor.evidence, ...(observedPlacement === undefined ? {} : { placement: observedPlacement }) },
-            stop: blocking ? verification : observedPlacement,
+            stop,
         };
     }
     return undefined;
 }
 async function advanceCandidate(input, cursor) {
-    if (input.start === "verification") {
-        const stopped = await verifyCandidateReadiness(input, cursor);
-        if (stopped !== undefined)
-            return stopped;
-    }
     const target = cursor.checkpoint.state.coordinates.target;
-    let placement = await placeCurrentCandidate(input, cursor);
+    let needsVerification = input.start === "verification";
     for (let cycles = 0;; cycles += 1) {
+        input.signal?.throwIfAborted();
+        let placement = await observeIntegrationTargetMovement(input.repository, cursor.checkpoint.state);
+        if (placement === undefined) {
+            if (needsVerification) {
+                const stopped = await verifyCandidateReadiness(input, cursor);
+                if (stopped !== undefined)
+                    return stopped;
+            }
+            placement = await placeCurrentCandidate(input, cursor);
+        }
         if (placement.kind === "accepted")
             return await completedResult(input, cursor);
         if (placement.kind !== "target-moved" || target === undefined || placement.observedTreeEqualsCandidate) {
@@ -287,10 +279,7 @@ async function advanceCandidate(input, cursor) {
             return stoppedResult(cursor, reintegrationStop(reintegrated));
         cursor.checkpoint = contractCheckpoint(reintegrated);
         input.progress.recordResidue(reintegrated.state.id, reintegrated);
-        const stopped = await verifyCandidateReadiness(input, cursor);
-        if (stopped !== undefined)
-            return stopped;
-        placement = await placeCurrentCandidate(input, cursor);
+        needsVerification = true;
     }
 }
 /** Advance one contract. The trigger owns the leading act; this node owns no other contract. */

package/build/src/protocol/deliver.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { worktreeWorkspaceSchema } from "../git/workspace.js";
-import type { ActorId, ContractId, ContractState, DeliverData } from "../core/facts/types.js";
+import { candidateContentChangeSchema } from "./operations.js";
+import type { ActorId, ContractId, ContractState, DeliverData, SnapshotId } from "../core/facts/types.js";
 import { type CurrentVerifiedAttestation } from "./intent.js";
 import type { LeadingOutcome } from "./outcome.js";
 import type { CompletionEvidence } from "./completion.js";
@@ -14,21 +14,22 @@ export declare const deliverLeadingSchema: z.ZodObject<{
         "already-admitted": "already-admitted";
     }>;
     fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+    reusedIntegration: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
 }, z.core.$strict>;
 type DeliverLeading = z.infer<typeof deliverLeadingSchema>;
 type DeliverValue = DeliveryIdentity & CompletionEvidence & Readonly<{
     leading: DeliverLeading;
+    contentChange?: z.infer<typeof candidateContentChangeSchema>;
 }>;
-export type AppointedWorkspace = z.infer<typeof worktreeWorkspaceSchema>;
 export declare const materializedConflictSchema: z.ZodObject<{
     kind: z.ZodLiteral<"integration-conflict-materialized">;
-    targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<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>>;
+    handoffBase: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
     recovery: z.ZodObject<{
         materialize: z.ZodLiteral<"deliver --materialize-conflict --include-dirty">;
         deliver: z.ZodLiteral<"deliver --include-dirty">;
@@ -49,6 +50,7 @@ type DeliverOperationRefusal = import("../core/verbs/deliver.js").DeliverRefusal
 export declare function prepareDelivery(repository: import("../git/process.js").GitRepository, stage: Readonly<{
     contractId: ContractId;
     coordinates: ContractState["coordinates"];
+    recordedIntegrations?: readonly SnapshotId[];
     appointment?: Extract<ManagedWorktreeAppointment, {
         kind: "appointed";
     }>;