@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/protocol/intent.js

@@ -3,32 +3,54 @@ import { projectSettings } from "../settings.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { latestCurrentAttestations } from "../core/facts/gate.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
-import { executeVerification, } from "../verification/execution.js";
+import { executeVerification, capturedOutput, } from "../verification/execution.js";
 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) {
     return outcome.kind === "spawn-error"
-        ? { failure: outcome.kind, diagnostic: outcome.diagnostic }
-        : { failure: outcome.kind };
+        ? { failure: outcome.kind, diagnostic: outcome.diagnostic, ...capturedOutput(outcome) }
+        : { failure: outcome.kind, ...capturedOutput(outcome) };
 }
 function verificationInput(outcome, input, subject) {
     return {
@@ -61,6 +83,33 @@ function retainVerificationReceipt(input, step) {
     if (!("failure" in step) && step.kind === "accepted")
         input.progress?.recordResidue(input.contractId, step);
 }
+async function verificationStep(input, execution, subject) {
+    if (execution.outcome.kind === "terminal") {
+        return await admitIntent(input.channel, input.repository, verificationInput(execution.outcome, input, subject), decideAttestation, input.progress === undefined ? {} : { progress: input.progress });
+    }
+    if (execution.outcome.kind === "candidate-unavailable")
+        return { failure: "candidate-unavailable", diagnostic: execution.outcome.diagnostic };
+    if (execution.outcome.kind === "environment-failure") {
+        return "diagnostic" in execution.outcome
+            ? { failure: "environment-failure", diagnostic: execution.outcome.diagnostic }
+            : { failure: "environment-failure", name: execution.outcome.name, detail: execution.outcome.detail };
+    }
+    if (execution.outcome.kind === "unknown-exit" ||
+        execution.outcome.kind === "cancelled" ||
+        execution.outcome.kind === "spawn-error")
+        return runtimeStop(execution.outcome);
+    throw new Error("Verification execution returned an invalid outcome");
+}
+function verificationCounts(execution) {
+    if (execution.outcome.kind !== "terminal")
+        return undefined;
+    return {
+        passed: execution.outcome.passed,
+        total: execution.outcome.total,
+        verdict: execution.outcome.verdict,
+        ...(execution.outcome.summary === undefined ? {} : { summary: execution.outcome.summary }),
+    };
+}
 /** Run Verification against an explicit or admitted integration snapshot. */
 export async function verifyDelivery(input) {
     const snapshot = input.snapshot ?? input.state.currentIntegration?.snapshot;
@@ -76,43 +125,16 @@ export async function verifyDelivery(input) {
         declarations: input.verification.declarations,
         materializeScratchCandidate,
         projectSettings,
+        observe: (observation) => input.progress?.observe({ kind: "verification", contractId: input.contractId, snapshot, observation }),
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
     input.progress?.recordVerification(input.contractId, snapshot, execution);
-    let step;
-    if (execution.outcome.kind === "terminal") {
-        step = await admitIntent(input.channel, input.repository, verificationInput(execution.outcome, input, subject), decideAttestation, input.progress === undefined ? {} : { progress: input.progress });
-    }
-    else if (execution.outcome.kind === "candidate-unavailable") {
-        step = { failure: "candidate-unavailable", diagnostic: execution.outcome.diagnostic };
-    }
-    else if (execution.outcome.kind === "environment-failure") {
-        step =
-            "diagnostic" in execution.outcome
-                ? { failure: "environment-failure", diagnostic: execution.outcome.diagnostic }
-                : { failure: "environment-failure", name: execution.outcome.name, detail: execution.outcome.detail };
-    }
-    else if (execution.outcome.kind === "unknown-exit" ||
-        execution.outcome.kind === "cancelled" ||
-        execution.outcome.kind === "spawn-error") {
-        step = runtimeStop(execution.outcome);
-    }
-    else {
-        throw new Error("Verification execution returned an invalid outcome");
-    }
+    const step = await verificationStep(input, execution, subject);
+    const counts = verificationCounts(execution);
     retainVerificationReceipt(input, step);
     return {
         step,
-        ...(execution.outcome.kind === "terminal"
-            ? {
-                counts: {
-                    passed: execution.outcome.passed,
-                    total: execution.outcome.total,
-                    verdict: execution.outcome.verdict,
-                    ...(execution.outcome.summary === undefined ? {} : { summary: execution.outcome.summary }),
-                },
-            }
-            : {}),
+        ...(counts === undefined ? {} : { counts }),
         ...(execution.cleanup === undefined ? {} : { cleanup: execution.cleanup }),
         ...(execution.leak === undefined ? {} : { leak: execution.leak }),
     };

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/progress.d.ts

@@ -4,6 +4,7 @@ import type { WorktreeLeak } from "../git/scratch.js";
 import type { PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { VerificationCleanupFailure } from "./intent.js";
 import type { AcceptedProtocolStep, IntentOutcome } from "./outcome.js";
+import { type ExecutionEvent, type ExecutionObserver } from "./execution-observation.js";
 /** A captured interpretation is not an invocation's admission receipt. */
 export type ContractCheckpoint = Readonly<{
     state: ContractState;
@@ -48,8 +49,11 @@ type Residue = Readonly<{
     physical?: ReconcileResult;
     seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
-/** Invocation-local receipts only: no persistence, scheduling, callbacks, or authority reads. */
+/** Invocation-local receipts and ephemeral observations; no scheduling or authority reads. */
 export declare class ExecutionProgress {
+    private readonly observer?;
+    constructor(observer?: ExecutionObserver | undefined);
+    observe(event: ExecutionEvent): void;
     private readonly entries;
     private readonly admittedFacts;
     private readonly admittedHeads;

package/build/src/protocol/progress.js

@@ -2,6 +2,7 @@ import { encodeEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { GitPlumbingError } from "../git/process.js";
 import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
+import { observeExecution } from "./execution-observation.js";
 export function contractCheckpoint(input) {
     return { state: input.state, journal: input.journal };
 }
@@ -21,8 +22,15 @@ export function executionStop(contractId, stage, error, signal) {
         diagnostic: error instanceof Error ? error.message : String(error),
     };
 }
-/** Invocation-local receipts only: no persistence, scheduling, callbacks, or authority reads. */
+/** Invocation-local receipts and ephemeral observations; no scheduling or authority reads. */
 export class ExecutionProgress {
+    observer;
+    constructor(observer) {
+        this.observer = observer;
+    }
+    observe(event) {
+        observeExecution(this.observer, event);
+    }
     entries = new Map();
     admittedFacts = [];
     admittedHeads = new Map();
@@ -50,6 +58,7 @@ export class ExecutionProgress {
                 continue;
             this.entries.set(key, bytes);
             this.admittedFacts.push(fact);
+            this.observe({ kind: "admitted", contractId, fact });
             this.affectedContracts.add(fact.contract);
             fresh = true;
         }

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

package/build/src/protocol/reintegrate.js

@@ -5,6 +5,7 @@ import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { timestamp } from "./operations.js";
+import { contractStateWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
 function reintegrationResultWithSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
@@ -13,38 +14,59 @@ function reintegrationResultWithSeatClose(outcome) {
         return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
     });
 }
+/** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
+async function prepareExternalReintegration(input) {
+    const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null)
+        return { kind: "unavailable" };
+    return {
+        kind: "artifacts",
+        witness: contractStateWitness(state),
+        artifacts: await planReintegrationArtifacts(input, state),
+    };
+}
+async function planReintegrationArtifacts(input, state) {
+    if (state.delivery === null || state.currentIntegration === null)
+        return { kind: "defer" };
+    const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
+    if (planned.kind === "refused")
+        return { kind: "refused", refusal: planned.refusal };
+    const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
+    return {
+        kind: "prepared",
+        data: { predecessor: planned.data.predecessor, snapshot },
+        assertion: { ref: input.target, oid: planned.data.predecessor },
+    };
+}
+/** Assemble the decision input from the fresh Contract; spent artifacts restart the whole cycle. */
+function assembleReintegrationAttempt(input, observation, external) {
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null) {
+        return external.kind === "unavailable"
+            ? { kind: "unavailable", refusal: { kind: "contract-missing", contractId: input.contractId } }
+            : STALE_PRIVATE_STATE_PREPARATION;
+    }
+    if (external.kind === "unavailable")
+        return STALE_PRIVATE_STATE_PREPARATION;
+    if (external.witness.head !== state.head)
+        return STALE_PRIVATE_STATE_PREPARATION;
+    if (state.delivery === null || state.currentIntegration === null) {
+        return { kind: "unavailable", refusal: { kind: "delivery-missing", contractId: input.contractId } };
+    }
+    return external.artifacts.kind === "defer" ? STALE_PRIVATE_STATE_PREPARATION : external.artifacts;
+}
 async function runReintegration(input) {
-    return reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
-        const attempts = mintAttempts({ entryCount: 1 });
-        for (let index = 0; index < attempts.length; index += 1) {
-            const attempt = attempts[index];
+    const attempts = mintAttempts({ entryCount: 1 });
+    for (let index = 0; index < attempts.length; index += 1) {
+        const attempt = attempts[index];
+        const external = await prepareExternalReintegration(input);
+        const result = reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
             const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
-            const state = contractState(observation.decision, input.contractId);
-            let preparation;
-            let assertions = [];
-            if (state === null || state.delivery === null || state.currentIntegration === null) {
-                preparation = {
-                    kind: "refused",
-                    refusal: {
-                        kind: state === null ? "contract-missing" : "delivery-missing",
-                        contractId: input.contractId,
-                    },
-                };
-            }
-            else {
-                const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
-                if (planned.kind === "refused") {
-                    preparation = planned;
-                }
-                else {
-                    const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
-                    preparation = {
-                        kind: "prepared",
-                        data: { predecessor: planned.data.predecessor, snapshot },
-                    };
-                    assertions = [{ ref: input.target, oid: planned.data.predecessor }];
-                }
-            }
+            const assembled = assembleReintegrationAttempt(input, observation, external);
+            if (assembled.kind === "stale")
+                return assembled;
+            const preparation = assembled.kind === "unavailable" ? { kind: "refused", refusal: assembled.refusal } : assembled;
             const decision = decideReintegrate({
                 input: {
                     contractId: input.contractId,
@@ -57,7 +79,7 @@ async function runReintegration(input) {
             });
             if (decision.kind === "refused")
                 return { kind: "refused", refusal: decision.refusal };
-            const result = await admitDecidedOffer({
+            const admitted = await admitDecidedOffer({
                 channel: input.channel,
                 repository: input.repository,
                 seat,
@@ -65,21 +87,26 @@ async function runReintegration(input) {
                 attempt,
                 offer: decision.offer,
                 primaryContract: input.contractId,
-                ...(input.progress === undefined ? {} : input.progress === undefined ? {} : { progress: input.progress }),
-                assertions,
+                ...(input.progress === undefined ? {} : { progress: input.progress }),
+                ...(assembled.kind === "prepared" ? { assertions: [assembled.assertion] } : {}),
             });
-            if (result.kind === "accepted") {
-                if (preparation.kind !== "prepared")
+            if (admitted.kind === "accepted") {
+                if (assembled.kind !== "prepared")
                     throw new Error("accepted reintegration has no preparation");
-                return { ...result, value: preparation.data };
+                return { ...admitted, value: assembled.data };
             }
-            if (result.kind === "publication-failed")
-                return { kind: "retry", reason: result };
-            if (result.kind === "collision" && index + 1 === attempts.length)
-                return { kind: "retry", reason: result };
-        }
-        return { kind: "retry", reason: { kind: "exhausted" } };
-    }));
+            return admitted;
+        }));
+        if (result.kind === "accepted" || result.kind === "refused")
+            return result;
+        if (result.kind === "stale" || result.kind === "redecide")
+            continue;
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    return { kind: "retry", reason: { kind: "exhausted" } };
 }
 export async function reintegrateOperation(input) {
     return await runUnderTargetPlacementFence(input.repository, input.target, async () => await runReintegration(input));

package/build/src/protocol/result-codec.js

@@ -31,6 +31,11 @@ function nonblank(value) {
         fail();
     return value;
 }
+function nonempty(value) {
+    if (typeof value !== "string" || value.length === 0)
+        fail();
+    return value;
+}
 function integer(value) {
     if (typeof value !== "number" || !Number.isInteger(value))
         fail();
@@ -104,10 +109,10 @@ export function decodeDeliverConflictRefusal(value) {
     const object = record(value, ["kind", "contractId", "reason", "targetHead", "conflictPaths", "recovery"]);
     if (object.kind !== "integration-failed" || object.reason !== "conflict")
         fail();
-    const recovery = record(object.recovery, ["materialize", "continue", "staging"]);
+    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
     if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
         fail();
-    if (recovery.continue !== "deliver --include-dirty")
+    if (recovery.deliver !== "deliver --include-dirty")
         fail();
     if (recovery.staging !== "not-required")
         fail();
@@ -119,7 +124,7 @@ export function decodeDeliverConflictRefusal(value) {
         conflictPaths: strings(object.conflictPaths),
         recovery: {
             materialize: "deliver --materialize-conflict --include-dirty",
-            continue: "deliver --include-dirty",
+            deliver: "deliver --include-dirty",
             staging: "not-required",
         },
     };
@@ -157,17 +162,25 @@ export function decodeIntentRefusal(value) {
         decodeVerificationDeclarationRefusal,
     ]);
 }
+function decodeCapturedVerificationOutput(object) {
+    return {
+        ...("stdout" in object ? { stdout: nonempty(object.stdout) } : {}),
+        ...("stderr" in object ? { stderr: nonempty(object.stderr) } : {}),
+        ...("truncated" in object ? (object.truncated === true ? { truncated: true } : fail()) : {}),
+    };
+}
 export function decodeVerificationRuntimeStop(value) {
-    const object = record(value, ["failure"], ["diagnostic", "name", "detail"]);
+    const object = record(value, ["failure"], ["diagnostic", "name", "detail", "stdout", "stderr", "truncated"]);
+    const output = decodeCapturedVerificationOutput(object);
     if (object.failure === "unknown-exit" || object.failure === "cancelled") {
         if ("diagnostic" in object || "name" in object || "detail" in object)
             fail();
-        return { failure: object.failure };
+        return { failure: object.failure, ...output };
     }
     if (object.failure === "candidate-unavailable" || object.failure === "spawn-error") {
         if ("name" in object || "detail" in object)
             fail();
-        return { failure: object.failure, diagnostic: nonblank(object.diagnostic) };
+        return { failure: object.failure, diagnostic: nonblank(object.diagnostic), ...output };
     }
     if (object.failure !== "environment-failure")
         fail();
@@ -178,9 +191,10 @@ export function decodeVerificationRuntimeStop(value) {
             failure: "environment-failure",
             name: nonblank(object.name),
             detail: decodeHookFailure(object.detail),
+            ...output,
         };
     }
-    return { failure: "environment-failure", diagnostic: nonblank(object.diagnostic) };
+    return { failure: "environment-failure", diagnostic: nonblank(object.diagnostic), ...output };
 }
 function decodeVerificationStepRefusal(value) {
     const object = record(value, ["refusal"]);
@@ -285,9 +299,11 @@ export function decodeVerificationCleanupFailure(value) {
     return { phase: "destroy", name: nonblank(object.name), detail: decodeHookFailure(object.detail) };
 }
 export function decodeCandidateCompletion(value) {
-    const object = record(value, ["integration"], ["verification"]);
+    const object = record(value, ["integration"], ["predecessor", "target", "verification"]);
     const completion = {
         integration: decodeSnapshotId(object.integration),
+        ...(object.predecessor === undefined ? {} : { predecessor: decodeSnapshotId(object.predecessor) }),
+        ...(object.target === undefined ? {} : { target: nonblank(object.target) }),
         ...(object.verification === undefined
             ? {}
             : {
@@ -325,10 +341,10 @@ export function decodeMaterializedConflict(value) {
     const object = record(value, ["kind", "targetHead", "conflictPaths", "workspace", "handoffBase", "recovery"]);
     if (object.kind !== "integration-conflict-materialized")
         fail();
-    const recovery = record(object.recovery, ["materialize", "continue", "staging"]);
+    const recovery = record(object.recovery, ["materialize", "deliver", "staging"]);
     if (recovery.materialize !== "deliver --materialize-conflict --include-dirty")
         fail();
-    if (recovery.continue !== "deliver --include-dirty")
+    if (recovery.deliver !== "deliver --include-dirty")
         fail();
     if (recovery.staging !== "not-required")
         fail();
@@ -340,7 +356,7 @@ export function decodeMaterializedConflict(value) {
         handoffBase: decodeSnapshotId(object.handoffBase),
         recovery: {
             materialize: "deliver --materialize-conflict --include-dirty",
-            continue: "deliver --include-dirty",
+            deliver: "deliver --include-dirty",
             staging: "not-required",
         },
     };