@astrosheep/keiyaku 4.6.4 → 4.6.7

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

@@ -10,22 +10,9 @@ import type { AttemptContext } from "../core/decide.js";
 import type { Offer } from "../core/facts/offer.js";
 import { type ContractId, type ContractState, type EntryUlid, type JournalEntry } from "../core/facts/types.js";
 export declare const entryUlidSchema: z.ZodPipe<z.ZodString, z.ZodTransform<EntryUlid, string>>;
-export declare function mintEntryUlids(count: number): readonly EntryUlid[];
 export declare function mintAttempts(input: Readonly<{
     entryCount: number;
 }>): readonly AttemptContext[];
-export type UnknownAttemptClassification = Readonly<{
-    kind: "accepted";
-}> | Readonly<{
-    kind: "redecide";
-}> | Readonly<{
-    kind: "collision";
-    contractId: ContractId;
-    planned: JournalEntry;
-    observed: JournalEntry;
-    plannedBytes: string;
-    observedBytes: string;
-}>;
 export type AcceptedAdmission = Readonly<{
     kind: "accepted";
     facts: readonly JournalEntry[];
@@ -46,18 +33,14 @@ export type DecidedOfferResult<Refusal = never> = AcceptedAdmission | AttemptTer
 }>;
 /** Admit one decided offer without making another legal decision. */
 export declare function admitDecidedOffer<Refusal = never>(input: Readonly<{
+    scope: GitRepository;
     channel: GitDecodeChannel;
-    repository: GitRepository;
+    contractId: ContractId;
     seat: PrivateStatePublicationSeat;
-    decisionObservation: GitDecisionObservation;
+    observation: GitDecisionObservation;
     attempt: AttemptContext;
     offer: Offer;
-    primaryContract: ContractId;
     assertions?: readonly GitRefAssertion[];
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     progress?: ProtocolProgress;
 }>): Promise<DecidedOfferResult<Refusal>>;
-/** Classify an unknown atomic-publication outcome using only a captured Git observation. */
-export declare function classifyUnknownAttempt(observation: Readonly<{
-    contracts: GitDecisionObservation["journals"];
-}>, offer: Offer): UnknownAttemptClassification;

package/build/src/protocol/attempt.js

@@ -34,7 +34,7 @@ function nextEntryUlid() {
     }
     return entryUlid(value);
 }
-export function mintEntryUlids(count) {
+function mintEntryUlids(count) {
     return Array.from({ length: count }, nextEntryUlid);
 }
 export function mintAttempts(input) {
@@ -104,7 +104,8 @@ async function publicationPremiseMoved(repository, observation, offer, assertion
 }
 /** Admit one decided offer without making another legal decision. */
 export async function admitDecidedOffer(input) {
-    const { repository, decisionObservation, attempt, offer, primaryContract } = input;
+    const { seat, observation: decisionObservation, attempt, offer, contractId: primaryContract } = input;
+    const repository = input.scope;
     const assertions = input.assertions ?? [];
     validateOffer(offer, attempt);
     const primary = primaryAppend(offer, primaryContract);
@@ -115,7 +116,7 @@ export async function admitDecidedOffer(input) {
     }
     const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
-        confirmPrivateStatePublication(input.seat);
+        confirmPrivateStatePublication(seat);
         input.progress?.recordPublication(primaryContract, admission.heads[primary.contractId], offerEntries(offer));
         const accepted = {
             kind: "accepted",
@@ -135,7 +136,7 @@ export async function admitDecidedOffer(input) {
     const recovered = await withGitDecodeChannel(recoveryRepository, async (recoveryChannel) => observeContractsForAdmissionAt(recoveryRepository, recoveryChannel, offer.facts.map((append) => append.contractId)));
     const classification = classifyUnknownAttempt({ contracts: recovered.journals }, offer);
     if (classification.kind === "accepted") {
-        const accepted = confirmRecoveredAcceptance(input.seat, { contracts: recovered.journals }, offer, primaryContract);
+        const accepted = confirmRecoveredAcceptance(seat, { contracts: recovered.journals }, offer, primaryContract);
         input.progress?.recordAdmission(accepted);
         return accepted;
     }
@@ -147,7 +148,7 @@ function confirmRecoveredAcceptance(seat, observation, offer, primaryContract) {
     return recovered;
 }
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */
-export function classifyUnknownAttempt(observation, offer) {
+function classifyUnknownAttempt(observation, offer) {
     let exact = 0;
     let missing = 0;
     for (const append of offer.facts) {

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

@@ -75,6 +75,7 @@ export declare const auditReportSchema: z.ZodObject<{
             path: z.ZodString;
         }, z.core.$strict>;
         identity: z.ZodObject<{
+            note: z.ZodOptional<z.ZodString>;
             tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
             integration: z.ZodObject<{
                 predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;

package/build/src/protocol/audit.js

@@ -11,7 +11,7 @@ import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { currentVerifiedAttestation, verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
-import { timestamp, unpackVerificationOutcome } from "./operations.js";
+import { recordedIntegrationSnapshots, timestamp, unpackVerificationOutcome } from "./operations.js";
 export const auditReportSchema = z
     .object({
     candidate: z.union([
@@ -63,15 +63,15 @@ async function auditWorkspace(repository, state) {
         return appointed;
     return { kind: "ready", answer: { kind: "worktree", path: appointed.path }, appointment: appointed };
 }
-function auditDeliveryRelation(state, candidate, verificationDeclared) {
+function auditDeliveryRelation(state, candidate, declaration) {
     const recorded = state.delivery?.data.integration.changeId;
     if (recorded === undefined)
         return undefined;
-    const verification = currentVerifiedAttestation(state);
+    const verification = declaration == null ? undefined : currentVerifiedAttestation(state);
     return {
         changeId: recorded,
         relation: recorded === candidate.integration.changeId ? "identical" : "differs",
-        verification: !verificationDeclared
+        verification: declaration == null
             ? { kind: "undeclared" }
             : verification === undefined
                 ? { kind: "unrecorded" }
@@ -95,15 +95,13 @@ async function auditCandidateVerification(input, state, snapshot, definition) {
         throw new Error("audit verification preparation unexpectedly produced no attempt");
     return unpackVerificationOutcome(verification);
 }
-function auditVerificationAnswer(verified, declared) {
-    if (!declared)
+function auditVerificationAnswer(verified, declaration) {
+    if (declaration === null)
         return { kind: "undeclared" };
     if (verified === undefined)
-        return { kind: "not-run" };
+        throw new Error("declared audit Verification produced no attempt");
     if (verified.stop !== undefined)
         return { kind: "stopped", stop: verified.stop };
-    if (verified.reuse !== undefined)
-        return { kind: "reused", ...verified.reuse };
     if (verified.counts === undefined)
         throw new Error("terminal Verification is missing producer counts");
     return {
@@ -172,6 +170,7 @@ export async function auditOperation(input) {
     const prepared = await prepareDelivery(input.scope, {
         contractId: state.id,
         coordinates: state.coordinates,
+        recordedIntegrations: recordedIntegrationSnapshots(observed.journals.get(state.id)?.entries ?? []),
         ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
     }, {
         title: derivation.title,
@@ -187,8 +186,8 @@ export async function auditOperation(input) {
     const verified = derivation.verification.data === null
         ? undefined
         : await auditCandidateVerification(input, state, prepared.data.integration.snapshot, derivation.verification.data);
-    const verification = auditVerificationAnswer(verified, derivation.verification.data !== null);
-    const delivery = auditDeliveryRelation(verified?.admission?.state ?? state, prepared.data, derivation.verification.data !== null);
+    const verification = auditVerificationAnswer(verified, derivation.verification.data);
+    const delivery = auditDeliveryRelation(verified?.admission?.state ?? state, prepared.data, derivation.verification.data);
     input.progress?.recordAudit(state.id, { verification, ...(delivery === undefined ? {} : { delivery }) });
     const target = await auditTargetAnswer(input.scope, state, prepared.data);
     input.progress?.recordAudit(state.id, { target });

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";
     }>;