@astrosheep/keiyaku 4.5.20 → 4.5.21

package/build/src/protocol/deliver.js

@@ -2,7 +2,7 @@ import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegrat
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { checkoutDetachedSnapshot, recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, conflictRecovery, } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { matchingPrivateRootObservation, privateStateSeatAttempt, sameSpeculativeWorktreeInput, } from "./run.js";
+import { contractStateWitness, privateStateSeatAttempt, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { currentVerifiedAttestation } from "./intent.js";
@@ -134,52 +134,132 @@ function hasSupersedingVerification(state, journal) {
     const verificationIndex = journal.findIndex((entry) => entry.entry === current.entry);
     return deliveryIndex >= 0 && verificationIndex > deliveryIndex;
 }
-async function speculateDelivery(input) {
+/**
+ * Repeatable physical delivery work outside the publication seat: locate the appointed worktree from
+ * one non-authoritative private-state read, capture its bytes, and materialize the prepared artifacts.
+ */
+async function prepareExternalDelivery(input) {
     const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(observation.decision, input.contractId);
-    const derivation = state === null ? undefined : input.deriveDocument(state);
-    if (state === null || derivation === undefined) {
-        return { observation, state, preparation: { kind: "unavailable" } };
+    if (state === null)
+        return { kind: "unavailable" };
+    return {
+        kind: "artifacts",
+        witness: contractStateWitness(state),
+        artifacts: await prepareDeliveryArtifacts(input, observation, state),
+    };
+}
+async function prepareDeliveryArtifacts(input, observation, state) {
+    const derivation = input.deriveDocument(state);
+    if (derivation.verification.kind === "refused")
+        return { kind: "defer" };
+    if (reusesCurrentCandidate(input, state, derivation))
+        return { kind: "defer" };
+    if (input.materializeConflict === true && state.terminal === null)
+        return { kind: "defer" };
+    const captured = await captureAuthorizedDeliveryTender(input.scope, { contractId: state.id, coordinates: state.coordinates }, input.includeDirty);
+    if (captured.kind === "refused")
+        return { kind: "refused", refusal: captured.refusal };
+    const worktree = await worktreeInput(input.scope, state, captured.data);
+    if (state.terminal === null &&
+        state.delivery !== null &&
+        worktree.changeId === state.delivery.data.integration.changeId &&
+        !hasSupersedingVerification(state, observation.journals.get(state.id)?.entries ?? [])) {
+        return {
+            kind: "continuation",
+            worktree,
+        };
     }
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, captured.data);
+    return prepared.kind === "prepared"
+        ? { kind: "mechanical", data: prepared.data, worktree: prepared.worktree }
+        : { kind: "refused", refusal: prepared.refusal };
+}
+/**
+ * Assemble the in-custody decision input from the fresh Contract. State-derived choices are recomputed
+ * here; artifacts the fresh state cannot justify are spent, which restarts the whole preparation.
+ */
+async function assembleDeliveryAttempt(input, observation, external) {
+    const state = contractState(observation.decision, input.contractId);
+    if (external.kind === "unavailable") {
+        return state === null
+            ? { kind: "assembled", state: null, preparation: { kind: "unavailable" } }
+            : { kind: "stale" };
+    }
+    if (state === null)
+        return { kind: "stale" };
+    if (external.witness.head !== state.head)
+        return { kind: "stale" };
+    const derivation = input.deriveDocument(state);
     if (derivation.verification.kind === "refused") {
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
             preparation: { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal },
         };
     }
     if (reusesCurrentCandidate(input, state, derivation))
-        return { observation, state, derivation };
-    if (input.materializeConflict === true && state.terminal === null)
-        return { observation, state, derivation };
-    const captured = await captureAuthorizedDeliveryTender(input.scope, { contractId: state.id, coordinates: state.coordinates }, input.includeDirty);
-    if (captured.kind === "refused") {
+        return { kind: "assembled", state, derivation };
+    const artifacts = external.artifacts;
+    if (artifacts.kind === "defer")
+        return await completeDeferredDelivery(input, state, derivation);
+    if (artifacts.kind === "refused") {
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
-            preparation: { kind: "refused", document: derivation.document, refusal: captured.refusal },
+            preparation: { kind: "refused", document: derivation.document, refusal: artifacts.refusal },
         };
     }
-    const capturedWorktree = await worktreeInput(input.scope, state, captured.data);
-    if (state.terminal === null &&
-        state.delivery !== null &&
-        capturedWorktree.changeId === state.delivery.data.integration.changeId &&
-        !hasSupersedingVerification(state, observation.journals.get(state.id)?.entries ?? [])) {
+    if (!sameWorktreeWitness(artifacts.worktree, await recaptureDeliveryWorktree(input, state))) {
+        return { kind: "stale" };
+    }
+    if (artifacts.kind === "continuation") {
+        const delivery = state.delivery;
+        if (delivery === null)
+            return { kind: "stale" };
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
-            preparation: { kind: "prepared", document: derivation.document, data: state.delivery.data },
-            worktree: capturedWorktree,
+            preparation: { kind: "prepared", document: derivation.document, data: delivery.data },
             continuation: true,
         };
     }
-    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, captured.data);
-    return prepared.kind === "prepared"
-        ? { observation, state, derivation, preparation: prepared, worktree: prepared.worktree }
-        : { observation, state, derivation, preparation: prepared };
+    return {
+        kind: "assembled",
+        state,
+        derivation,
+        preparation: { kind: "prepared", document: derivation.document, data: artifacts.data },
+    };
+}
+/**
+ * Complete a preparation the outside phase could not settle. A requested conflict materialization
+ * must retire its owned handoff and then capture the worktree that follows, so it only runs under
+ * this custody; every other deferred state is decided by reuse above or refuses on its own.
+ */
+async function completeDeferredDelivery(input, state, derivation) {
+    if (input.materializeConflict !== true || state.terminal !== null)
+        return { kind: "assembled", state, derivation };
+    const materialization = await materializationMergeStateRefusal(input);
+    if (materialization !== undefined) {
+        return {
+            kind: "assembled",
+            state,
+            derivation,
+            preparation: { kind: "refused", document: derivation.document, refusal: materialization },
+        };
+    }
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation);
+    return {
+        kind: "assembled",
+        state,
+        derivation,
+        preparation: prepared.kind === "prepared"
+            ? { kind: "prepared", document: derivation.document, data: prepared.data }
+            : prepared,
+    };
 }
 function reusesCurrentCandidate(input, state, derivation) {
     return (input.overwrite !== true &&
@@ -189,60 +269,54 @@ function reusesCurrentCandidate(input, state, derivation) {
         derivation.verification.data !== null &&
         currentVerifiedAttestation(state) === undefined);
 }
-async function resolveDeliveryPreparation(input, speculated) {
-    if (speculated.preparation !== undefined)
-        return speculated.preparation;
-    if (speculated.state === null || speculated.derivation === undefined)
-        return { kind: "unavailable" };
-    const materialization = await materializationMergeStateRefusal(input);
-    if (materialization !== undefined) {
-        return { kind: "refused", document: speculated.derivation.document, refusal: materialization };
-    }
-    const prepared = await mechanicalDeliveryPreparation(input, speculated.state, speculated.derivation);
-    return prepared.kind === "prepared"
-        ? { kind: "prepared", document: prepared.document, data: prepared.data }
-        : prepared;
+/** Accept a delivery whose current candidate is already admitted, without admitting it again. */
+function currentCandidateDeliveryDecision(input, observation, assembled) {
+    const state = assembled.state;
+    if (state === null || assembled.derivation === undefined)
+        return undefined;
+    if (!reusesCurrentCandidate(input, state, assembled.derivation))
+        return undefined;
+    const record = observation.journals.get(input.contractId);
+    const delivery = record?.entries.findLast((entry) => entry.kind === "deliver");
+    if (record === undefined || delivery === undefined)
+        throw new Error("current delivery is missing its journal fact");
+    input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
+    return {
+        kind: "accepted",
+        facts: [],
+        state,
+        journal: record.entries,
+        value: {
+            ...state.delivery.data,
+            leading: { kind: "already-admitted", fact: delivery.entry },
+        },
+    };
 }
-async function decideAndAdmitDelivery(input, attempt, seat, observation, speculated) {
-    const currentState = speculated.state;
-    if (currentState !== null &&
-        speculated.derivation !== undefined &&
-        reusesCurrentCandidate(input, currentState, speculated.derivation)) {
-        const record = observation.journals.get(input.contractId);
-        const delivery = record?.entries.findLast((entry) => entry.kind === "deliver");
-        if (record === undefined || delivery === undefined)
-            throw new Error("current delivery is missing its journal fact");
-        input.progress?.recordAdmission({ kind: "accepted", facts: [], state: currentState, journal: record.entries });
-        return {
-            kind: "accepted",
-            facts: [],
-            state: currentState,
-            journal: record.entries,
-            value: {
-                ...currentState.delivery.data,
-                leading: { kind: "already-admitted", fact: delivery.entry },
-            },
-        };
-    }
-    if (speculated.continuation === true) {
-        const record = observation.journals.get(input.contractId);
-        if (record === undefined ||
-            record.state === null ||
-            record.state.delivery === null ||
-            speculated.derivation === undefined) {
-            return { kind: "redecide" };
-        }
-        const state = record.state;
-        input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
-        return {
-            kind: "accepted",
-            facts: [],
-            state,
-            journal: record.entries,
-            value: record.state.delivery.data,
-        };
+/** Continue the admitted integration this worktree already carries, without a new offer. */
+function continuationDeliveryDecision(input, observation, assembled) {
+    const record = observation.journals.get(input.contractId);
+    const state = record?.state ?? null;
+    if (record === undefined || state === null || state.delivery === null || assembled.derivation === undefined) {
+        return { kind: "redecide" };
     }
-    const preparation = await resolveDeliveryPreparation(input, speculated);
+    input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
+    return {
+        kind: "accepted",
+        facts: [],
+        state,
+        journal: record.entries,
+        value: state.delivery.data,
+    };
+}
+async function decideAndAdmitDelivery(input, attempt, seat, observation, assembled) {
+    const current = currentCandidateDeliveryDecision(input, observation, assembled);
+    if (current !== undefined)
+        return current;
+    if (assembled.continuation === true)
+        return continuationDeliveryDecision(input, observation, assembled);
+    const preparation = assembled.preparation ?? STALE_PRIVATE_STATE_PREPARATION;
+    if (preparation.kind === "stale")
+        return preparation;
     const decision = decideDeliver({
         input: {
             contractId: input.contractId,
@@ -274,22 +348,19 @@ async function decideAndAdmitDelivery(input, attempt, seat, observation, specula
         value: preparation.data,
     };
 }
-async function deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated) {
-    const observation = await matchingPrivateRootObservation(input.scope, input.channel, input.contractId, speculated.observation, async (fresh) => {
-        if (speculated.worktree === undefined)
-            return true;
-        const state = contractState(fresh.decision, input.contractId);
-        if (state === null)
-            return false;
-        return sameSpeculativeWorktreeInput(speculated.worktree, await recaptureDeliveryWorktree(input, state));
-    });
-    return "kind" in observation
-        ? observation
-        : await decideAndAdmitDelivery(input, attempt, seat, observation, speculated);
-}
+/**
+ * One delivery attempt: the repeatable physical preparation happens outside custody, then a single
+ * in-custody observation, witness validation, assembly, decision, and atomic publication.
+ */
 async function deliverAttempt(input, attempt) {
-    const speculated = await speculateDelivery(input);
-    return await privateStateSeatAttempt(input.scope, async (seat) => await deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated), attemptDecisionWithSeatClose);
+    const external = await prepareExternalDelivery(input);
+    return await privateStateSeatAttempt(input.scope, async (seat) => {
+        const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+        const assembled = await assembleDeliveryAttempt(input, observation, external);
+        if (assembled.kind === "stale")
+            return STALE_PRIVATE_STATE_PREPARATION;
+        return await decideAndAdmitDelivery(input, attempt, seat, observation, assembled);
+    }, attemptDecisionWithSeatClose);
 }
 function isIntegrationConflict(refusal) {
     return refusal.kind === "integration-failed" && refusal.reason === "conflict";
@@ -417,6 +488,8 @@ export async function admitDeliveryOperation(input) {
             return await finishDeliverRefusal(input, result.refusal);
         if (result.kind === "publication-failed")
             return { kind: "retry", reason: result };
+        if (result.kind === "stale" || result.kind === "redecide")
+            continue;
         if (result.kind === "collision" && index + 1 === attempts.length)
             return { kind: "retry", reason: result };
     }

package/build/src/protocol/execution-observation.d.ts

@@ -128,12 +128,10 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         phase: z.ZodEnum<{
             cleanup: "cleanup";
             materialize: "materialize";
-            environment: "environment";
             setup: "setup";
             declaration: "declaration";
         }>;
         cwd: z.ZodOptional<z.ZodString>;
-        source: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         command: z.ZodOptional<z.ZodString>;
         index: z.ZodOptional<z.ZodNumber>;
@@ -148,12 +146,10 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         phase: z.ZodEnum<{
             cleanup: "cleanup";
             materialize: "materialize";
-            environment: "environment";
             setup: "setup";
             declaration: "declaration";
         }>;
         cwd: z.ZodOptional<z.ZodString>;
-        source: z.ZodOptional<z.ZodString>;
         name: z.ZodOptional<z.ZodString>;
         command: z.ZodOptional<z.ZodString>;
         index: z.ZodOptional<z.ZodNumber>;

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

@@ -2,7 +2,6 @@ import type { ExecutionProgress } from "./progress.js";
 import type { GitDecisionObservation } from "../git/observe.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
-import type { GitRefAssertion } from "../git/repository.js";
 import { type WorktreeLeak } from "../git/scratch.js";
 import type { HookFailure } from "../git/hooks.js";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
@@ -10,36 +9,32 @@ import type { ActorId, ContractId, ContractState, EntryUlid, SnapshotId } from "
 import { type AttestationRefusal } from "../core/verbs/attestation.js";
 import { type CapturedOutput } from "../verification/execution.js";
 import { type VerificationDefinition } from "../verification/declaration.js";
-import { type CompanionDecorator, type ProtocolResult } from "./run.js";
-type IntentAdmissionOptions<Input, Refusal, Seed> = Readonly<{
+import { type CompanionDecorator, type ProtocolPreparation, type ProtocolResult } from "./run.js";
+type CommonIntentAdmissionOptions<Refusal> = Readonly<{
     progress?: ExecutionProgress;
     observedContracts?: readonly ContractId[];
     observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
     decorateOffer?: CompanionDecorator;
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
-    prepareInput?: (observation: GitDecisionObservation, input: Seed) => Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }> | Promise<Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }>>;
 }>;
-/** Observe, decide, and atomically admit one intent with bounded Git retries. */
+type IntentAdmissionOptions<Refusal = never> = CommonIntentAdmissionOptions<Refusal>;
+type PreparedIntentAdmissionOptions<Input, Refusal, Seed, Prepared> = CommonIntentAdmissionOptions<Refusal> & Readonly<{
+    preparation: ProtocolPreparation<Input, Refusal, Seed, Prepared>;
+}>;
+/** Observe, decide, and atomically admit one intent whose invocation already is its decision input. */
 export declare function admitIntent<Input extends Readonly<{
     contractId: ContractId;
+}>, Refusal>(channel: GitDecodeChannel, repository: GitRepository, input: Input, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options?: IntentAdmissionOptions<Refusal>): Promise<ProtocolResult<Refusal>>;
+/**
+ * Observe, decide, and atomically admit one intent whose repeatable preparation happens outside
+ * the publication seat and whose decision input is assembled from the fresh in-custody observation.
+ */
+export declare function admitPreparedIntent<Input extends Readonly<{
+    contractId: ContractId;
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
-}> = Input>(channel: GitDecodeChannel, repository: GitRepository, input: Seed, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options?: IntentAdmissionOptions<Input, Refusal, Seed>): Promise<ProtocolResult<Refusal>>;
+}>, Prepared>(channel: GitDecodeChannel, repository: GitRepository, input: Seed, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options: PreparedIntentAdmissionOptions<Input, Refusal, Seed, Prepared>): Promise<ProtocolResult<Refusal>>;
 type VerifyDeliveryInput = Readonly<{
     channel: GitDecodeChannel;
     repository: GitRepository;

package/build/src/protocol/intent.js

@@ -1,6 +1,5 @@
 import { materializeScratchCandidate } from "../git/scratch.js";
 import { projectSettings } from "../settings.js";
-import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { latestCurrentAttestations } from "../core/facts/gate.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
@@ -8,22 +7,44 @@ import { executeVerification, capturedOutput, } from "../verification/execution.
 import { VERIFIED } from "../verification/declaration.js";
 import { runProtocol } from "./run.js";
 import { mintAttempts } from "./attempt.js";
-/** Observe, decide, and atomically admit one intent with bounded Git retries. */
+function admissionOptions(options) {
+    return {
+        ...(options.progress === undefined ? {} : { progress: options.progress }),
+        ...(options.observedContracts === undefined ? {} : { observedContracts: options.observedContracts }),
+        ...(options.observe === undefined ? {} : { observe: options.observe }),
+        ...(options.decorateOffer === undefined ? {} : { decorateOffer: options.decorateOffer }),
+        ...(options.validateAdmission === undefined ? {} : { validateAdmission: options.validateAdmission }),
+        ...(options.observationSelection === undefined ? {} : { observationSelection: options.observationSelection }),
+    };
+}
+/** Observe, decide, and atomically admit one intent whose invocation already is its decision input. */
 export function admitIntent(channel, repository, input, decide, options = {}) {
     const contracts = options.observedContracts ?? [input.contractId];
     return runProtocol({
+        ...admissionOptions(options),
         input,
         channel,
         repository,
         contracts,
         attempts: mintAttempts({ entryCount: 2 }),
         decide,
-        ...(options.progress === undefined ? {} : { progress: options.progress }),
-        ...(options.observe === undefined ? {} : { observe: options.observe }),
-        ...(options.decorateOffer === undefined ? {} : { decorateOffer: options.decorateOffer }),
-        ...(options.validateAdmission === undefined ? {} : { validateAdmission: options.validateAdmission }),
-        ...(options.observationSelection === undefined ? {} : { observationSelection: options.observationSelection }),
-        ...(options.prepareInput === undefined ? {} : { prepareInput: options.prepareInput }),
+    });
+}
+/**
+ * Observe, decide, and atomically admit one intent whose repeatable preparation happens outside
+ * the publication seat and whose decision input is assembled from the fresh in-custody observation.
+ */
+export function admitPreparedIntent(channel, repository, input, decide, options) {
+    const contracts = options.observedContracts ?? [input.contractId];
+    return runProtocol({
+        ...admissionOptions(options),
+        input,
+        preparation: options.preparation,
+        channel,
+        repository,
+        contracts,
+        attempts: mintAttempts({ entryCount: 2 }),
+        decide,
     });
 }
 function runtimeStop(outcome) {
@@ -98,21 +119,12 @@ export async function verifyDelivery(input) {
         { kind: "snapshot", value: snapshot },
         { kind: "segment", value: input.verification.segment },
     ]);
-    const appointment = await readManagedWorktreeAppointment(input.repository, input.contractId);
-    if (appointment.kind !== "appointed")
-        return {
-            step: {
-                failure: "environment-failure",
-                diagnostic: appointment.kind === "failed" ? appointment.diagnostic : "Verification environment source is not appointed",
-            },
-        };
     const execution = await executeVerification({
         repository: input.repository,
         candidate: snapshot,
         declarations: input.verification.declarations,
         materializeScratchCandidate,
         projectSettings,
-        environmentSource: appointment.path,
         observe: (observation) => input.progress?.observe({ kind: "verification", contractId: input.contractId, snapshot, observation }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });

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

@@ -103,6 +103,8 @@ export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission
     refusal: Refusal;
 }> | Readonly<{
     kind: "redecide";
+}> | Readonly<{
+    kind: "stale";
 }> | Readonly<{
     kind: "collision";
 }> | Extract<DecidedOfferResult, {

package/build/src/protocol/placement.js

@@ -49,7 +49,7 @@ async function runFencedPlacement(repository, input, protocol) {
         const result = placementResultWithSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
             // The hint carries no acceptance authority. Form a fresh semantic offer under the seat.
             const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
-            if (prepared.kind === "refused")
+            if (prepared.kind !== "offered")
                 return prepared;
             const state = contractState(prepared.observation.decision, input.contractId);
             if (state === null)
@@ -68,6 +68,8 @@ async function runFencedPlacement(repository, input, protocol) {
                     observedTreeEqualsCandidate: await observedTreeEqualsCandidate(repository, observed, target.newOid),
                 };
             if (changes?.predecessor !== target.expectedOid || changes.candidate !== target.newOid)
+                // A target preparation computed before custody is spent once the fresh offer names another
+                // movement. Re-derive it on the next attempt; never publish a preparation for stale bytes.
                 return { kind: "changed-preparation", target };
             const physical = await prepareTargetPlacement(repository, state, target, changes);
             if (physical.kind === "refused")
@@ -92,6 +94,8 @@ async function runFencedPlacement(repository, input, protocol) {
         }
         if (result.kind === "redecide")
             continue;
+        if (result.kind === "stale")
+            continue;
         if (result.kind === "collision" && index + 1 < protocol.attempts.length)
             continue;
         if (result.kind !== "accepted")

package/build/src/protocol/read/status.d.ts

@@ -19,6 +19,7 @@ export type ContractVerificationStatus = Readonly<{
     kind: "recorded";
     verdict: "satisfied" | "unsatisfied";
     at: string;
+    snapshot?: SnapshotId;
 }>;
 export type ContractTargetLag = GitContractTargetLag | Readonly<{
     kind: "counted";

package/build/src/protocol/read/status.js

@@ -1,5 +1,6 @@
 import { observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
 import { decodeContractDocument, verificationDefinition } from "../../body/decode.js";
+import { dependencyKeys } from "../../core/subject.js";
 import { observeTargetLag, observeWorkspace, conflictHandoffFor, conflictRecovery, worktreePath, } from "../../git/workspace.js";
 import { appointmentFor, readPlaceRegister } from "../../workspace-place.js";
 import { gateReports, latestCurrentAttestations } from "../../core/facts/gate.js";
@@ -36,8 +37,15 @@ function verificationFor(state, document) {
         return { kind: "undeclared" };
     const verifiedGate = gate("verified");
     const current = latestCurrentAttestations(state, new Set([verifiedGate])).get(verifiedGate);
-    if (current !== undefined)
-        return { kind: "recorded", verdict: current.data.verdict, at: current.at };
+    if (current !== undefined) {
+        const snapshot = dependencyKeys(current.data.subject).find((key) => key.kind === "snapshot")?.value;
+        return {
+            kind: "recorded",
+            verdict: current.data.verdict,
+            at: current.at,
+            ...(snapshot === undefined ? {} : { snapshot: snapshot }),
+        };
+    }
     return state.delivery === null ? undefined : { kind: "unrecorded" };
 }
 export function phaseAtFor(state, bindAt) {

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

@@ -5,7 +5,7 @@ import { type IntegrationPreparationRefusal } from "../git/integration.js";
 import type { GitRepository } from "../git/process.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type AcceptedAdmission } from "./attempt.js";
-import type { ProtocolTerminal } from "./run.js";
+import { type ProtocolTerminal } from "./run.js";
 import { type PlacementExecutionFailure } from "./placement.js";
 type TargetMissing = Readonly<{
     kind: "target-missing";