@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/protocol/deliver.js

@@ -2,19 +2,23 @@ import { entryUlidSchema } from "./attempt.js";
 import { z } from "zod";
 import { snapshotIdSchema } from "./operations.js";
 import { conflictRecoverySchema, worktreeWorkspaceSchema } from "../git/workspace.js";
-import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, worktreeChangeId, } from "../git/integration.js";
+import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, reusableIntegrationSnapshot, worktreeChangeId, } from "../git/integration.js";
 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 { contractStateWitness, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, 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";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+import { attemptDecisionWithSeatClose, recordedIntegrationSnapshots, timestamp } from "./operations.js";
 export const deliverLeadingSchema = z
-    .object({ kind: z.enum(["admitted-now", "already-admitted"]), fact: entryUlidSchema })
+    .object({
+    kind: z.enum(["admitted-now", "already-admitted"]),
+    fact: entryUlidSchema,
+    reusedIntegration: snapshotIdSchema.optional(),
+})
     .strict();
 export const materializedConflictSchema = z
     .object({
@@ -69,12 +73,16 @@ async function prepareDeliveryWithWorktree(repository, stage, input, captured) {
     if (integration.kind === "refused")
         return integration;
     const changeId = await worktreeChangeId(repository, { contractId, coordinates }, tender.data);
-    const integrationSnapshot = coordinates.target === undefined
-        ? tenderSnapshot
-        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, commit);
+    const reusedIntegration = await reusableIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, stage.recordedIntegrations ?? []);
+    const integrationSnapshot = reusedIntegration ??
+        (coordinates.target === undefined
+            ? tenderSnapshot
+            : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, commit));
     return {
         kind: "prepared",
+        ...(reusedIntegration === undefined ? {} : { reusedIntegration }),
         data: {
+            ...(input.message === undefined ? {} : { note: input.message }),
             tenderSnapshot,
             integration: {
                 predecessor: integration.data.predecessor,
@@ -119,8 +127,12 @@ async function recaptureDeliveryWorktree(input, state) {
         changeId: await worktreeChangeId(input.scope, { contractId: state.id, coordinates: state.coordinates }, tender.data),
     };
 }
-async function mechanicalDeliveryPreparation(input, state, derivation, captured) {
-    const prepared = await prepareDeliveryWithWorktree(input.scope, { contractId: state.id, coordinates: state.coordinates }, deliveryPreparationInput(input, derivation), captured);
+async function mechanicalDeliveryPreparation(input, state, derivation, journal, captured) {
+    const prepared = await prepareDeliveryWithWorktree(input.scope, {
+        contractId: state.id,
+        coordinates: state.coordinates,
+        recordedIntegrations: recordedIntegrationSnapshots(journal),
+    }, deliveryPreparationInput(input, derivation), captured);
     if (prepared.kind === "refused") {
         return { kind: "refused", document: derivation.document, refusal: prepared.refusal };
     }
@@ -129,6 +141,7 @@ async function mechanicalDeliveryPreparation(input, state, derivation, captured)
         document: derivation.document,
         data: prepared.data,
         worktree: prepared.worktree,
+        ...(prepared.reusedIntegration === undefined ? {} : { reusedIntegration: prepared.reusedIntegration }),
     };
 }
 function worktreeInput(repository, state, tender) {
@@ -155,28 +168,21 @@ function hasSupersedingVerification(state, journal) {
  * 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);
-    if (state === null)
-        return { kind: "unavailable" };
-    return {
-        kind: "artifacts",
-        witness: contractStateWitness(state),
-        artifacts: await prepareDeliveryArtifacts(input, observation, state),
-    };
+    return await externalPreparation(input, (observation, state) => 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 (reusesCurrentCandidate(input, state, derivation, worktree.changeId)) {
+        return { kind: "reuse", worktree };
+    }
     if (state.terminal === null &&
         state.delivery !== null &&
         worktree.changeId === state.delivery.data.integration.changeId &&
@@ -186,9 +192,14 @@ async function prepareDeliveryArtifacts(input, observation, state) {
             worktree,
         };
     }
-    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, captured.data);
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, observation.journals.get(state.id)?.entries ?? [], captured.data);
     return prepared.kind === "prepared"
-        ? { kind: "mechanical", data: prepared.data, worktree: prepared.worktree }
+        ? {
+            kind: "mechanical",
+            data: prepared.data,
+            worktree: prepared.worktree,
+            ...(prepared.reusedIntegration === undefined ? {} : { reusedIntegration: prepared.reusedIntegration }),
+        }
         : { kind: "refused", refusal: prepared.refusal };
 }
 /**
@@ -215,11 +226,9 @@ async function assembleDeliveryAttempt(input, observation, external) {
             preparation: { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal },
         };
     }
-    if (reusesCurrentCandidate(input, state, derivation))
-        return { kind: "assembled", state, derivation };
     const artifacts = external.artifacts;
     if (artifacts.kind === "defer")
-        return await completeDeferredDelivery(input, state, derivation);
+        return await completeDeferredDelivery(input, state, derivation, observation.journals.get(state.id)?.entries ?? []);
     if (artifacts.kind === "refused") {
         return {
             kind: "assembled",
@@ -231,6 +240,11 @@ async function assembleDeliveryAttempt(input, observation, external) {
     if (!sameWorktreeWitness(artifacts.worktree, await recaptureDeliveryWorktree(input, state))) {
         return { kind: "stale" };
     }
+    if (artifacts.kind === "reuse") {
+        return reusesCurrentCandidate(input, state, derivation, artifacts.worktree.changeId)
+            ? { kind: "assembled", state, derivation, reuse: true }
+            : { kind: "stale" };
+    }
     if (artifacts.kind === "continuation") {
         const delivery = state.delivery;
         if (delivery === null)
@@ -248,16 +262,21 @@ async function assembleDeliveryAttempt(input, observation, external) {
         state,
         derivation,
         preparation: { kind: "prepared", document: derivation.document, data: artifacts.data },
+        ...(artifacts.reusedIntegration === undefined ? {} : { reusedIntegration: artifacts.reusedIntegration }),
     };
 }
 /**
  * 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.
+ * this custody; an unchanged candidate may still be reused before that materialization.
  */
-async function completeDeferredDelivery(input, state, derivation) {
+async function completeDeferredDelivery(input, state, derivation, journal) {
     if (input.materializeConflict !== true || state.terminal !== null)
         return { kind: "assembled", state, derivation };
+    const worktree = await recaptureDeliveryWorktree(input, state);
+    if (worktree !== undefined && reusesCurrentCandidate(input, state, derivation, worktree.changeId)) {
+        return { kind: "assembled", state, derivation, reuse: true };
+    }
     const materialization = await materializationMergeStateRefusal(input);
     if (materialization !== undefined) {
         return {
@@ -267,30 +286,32 @@ async function completeDeferredDelivery(input, state, derivation) {
             preparation: { kind: "refused", document: derivation.document, refusal: materialization },
         };
     }
-    const prepared = await mechanicalDeliveryPreparation(input, state, derivation);
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, journal);
     return {
         kind: "assembled",
         state,
         derivation,
+        ...(prepared.kind !== "prepared" || prepared.reusedIntegration === undefined
+            ? {}
+            : { reusedIntegration: prepared.reusedIntegration }),
         preparation: prepared.kind === "prepared"
             ? { kind: "prepared", document: derivation.document, data: prepared.data }
             : prepared,
     };
 }
-function reusesCurrentCandidate(input, state, derivation) {
+function reusesCurrentCandidate(input, state, derivation, changeId) {
     return (input.overwrite !== true &&
         state.terminal === null &&
         state.delivery !== null &&
         derivation.verification.kind === "prepared" &&
         derivation.verification.data !== null &&
-        currentVerifiedAttestation(state) === undefined);
+        currentVerifiedAttestation(state) === undefined &&
+        state.delivery.data.integration.changeId === changeId);
 }
 /** 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))
+    if (state === null || assembled.derivation === undefined || assembled.reuse !== true)
         return undefined;
     const record = observation.journals.get(input.contractId);
     const delivery = record?.entries.findLast((entry) => entry.kind === "deliver");
@@ -353,26 +374,35 @@ async function decideAndAdmitDelivery(input, attempt, seat, observation, assembl
         return { kind: "refused", refusal: decision.refusal };
     if (preparation.kind !== "prepared")
         throw new Error("offered delivery is missing its mechanical preparation");
-    const admission = await admitDecidedOffer({
-        channel: input.channel,
-        repository: input.scope,
-        seat,
-        decisionObservation: observation,
-        attempt,
-        offer: decision.offer,
-        primaryContract: input.contractId,
-        ...(input.progress === undefined ? {} : { progress: input.progress }),
-    });
+    const admission = await admitDecidedOffer({ ...input, seat, observation, attempt, offer: decision.offer });
     if (admission.kind !== "accepted")
         return admission;
     const deliverFact = admission.facts.find((fact) => fact.contract === input.contractId && fact.kind === "deliver");
     if (deliverFact?.kind !== "deliver")
         throw new Error("confirmed delivery requires its own receipt");
+    const previousChange = assembled.state?.delivery?.data.integration.changeId;
+    const currentChange = preparation.data.integration.changeId;
     return {
         ...admission,
         value: {
             ...preparation.data,
-            leading: { kind: "admitted-now", fact: deliverFact.entry },
+            leading: {
+                kind: "admitted-now",
+                fact: deliverFact.entry,
+                ...(assembled.reusedIntegration === undefined ? {} : { reusedIntegration: assembled.reusedIntegration }),
+            },
+            ...(previousChange === undefined || previousChange === currentChange
+                ? {}
+                : {
+                    contentChange: {
+                        kind: "candidate-content-changed",
+                        ...(assembled.state?.coordinates.target === undefined
+                            ? {}
+                            : { target: assembled.state.coordinates.target }),
+                        previousChange,
+                        currentChange,
+                    },
+                }),
         },
     };
 }

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"admitted">;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
     fact: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
@@ -37,6 +37,7 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         at: string;
         actor?: import("../index.js").ActorId;
         data: Readonly<{
+            note?: string;
             tenderSnapshot: import("../index.js").SnapshotId;
             integration: Readonly<{
                 predecessor: import("../index.js").SnapshotId;
@@ -165,8 +166,5 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strict>], "kind">;
 export type ExecutionObservation = z.infer<typeof observationSchema>;
 export type ExecutionObserver = (event: ExecutionObservation) => void | PromiseLike<void>;
-/** One owner decoder for local and transported ephemeral observations. */
-export declare function decodeExecutionObservation(value: unknown): ExecutionObservation;
 /** Observation failure cannot change execution, admission, or process custody. */
 export declare function observeExecution(observer: ExecutionObserver | undefined, event: ExecutionObservation): void;
-export {};

package/build/src/protocol/execution-observation.js

@@ -1,13 +1,13 @@
 import { z } from "zod";
-import { decodeJournalEntry } from "../core/facts/codec.js";
+import { validateEntry } from "../core/facts/codec.js";
 import { contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 import { verificationObservationSchema } from "../verification/observation.js";
-const observationSchema = z.discriminatedUnion("kind", [
+export const observationSchema = z.discriminatedUnion("kind", [
     z
         .object({
         kind: z.literal("admitted"),
         contractId: contractIdSchema,
-        fact: z.unknown().transform(decodeJournalEntry),
+        fact: z.unknown().transform(validateEntry),
     })
         .strict(),
     z
@@ -28,10 +28,6 @@ const observationSchema = z.discriminatedUnion("kind", [
         .strict(),
     z.object({ kind: z.literal("progress-dropped"), count: z.number().int().positive() }).strict(),
 ]);
-/** One owner decoder for local and transported ephemeral observations. */
-export function decodeExecutionObservation(value) {
-    return observationSchema.parse(value);
-}
 /** Observation failure cannot change execution, admission, or process custody. */
 export function observeExecution(observer, event) {
     try {

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

@@ -17,7 +17,7 @@ type CommonIntentAdmissionOptions<Refusal> = Readonly<{
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
 }>;
-type IntentAdmissionOptions<Refusal = never> = CommonIntentAdmissionOptions<Refusal>;
+export type IntentAdmissionOptions<Refusal = never> = CommonIntentAdmissionOptions<Refusal>;
 type PreparedIntentAdmissionOptions<Input, Refusal, Seed, Prepared> = CommonIntentAdmissionOptions<Refusal> & Readonly<{
     preparation: ProtocolPreparation<Input, Refusal, Seed, Prepared>;
 }>;

package/build/src/protocol/intent.js

@@ -194,6 +194,7 @@ export async function verifyDelivery(input) {
     const execution = await executeVerification({
         repository: input.repository,
         candidate: snapshot,
+        contractId: input.contractId,
         declarations: input.verification.declarations,
         materializeScratchCandidate,
         projectSettings,

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import type { ContractId, ContractState, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
+import type { DecideInput, OfferDecision } from "../core/decide.js";
+import type { ActorId, ContractId, ContractState, DeliverData, DocumentKey, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { IntegrationPreparationRefusal } from "../git/integration.js";
 import { type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitRepository } from "../git/process.js";
@@ -7,17 +8,19 @@ import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
 import type { AcceptedAdmission, DecidedOfferResult } from "./attempt.js";
+import { type IntentAdmissionOptions } from "./intent.js";
 import type { VerificationCleanupFailure, VerificationResult } from "./intent.js";
-import type { AcceptedProtocolStep, IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
+import { type AcceptedProtocolStep, type IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
 import type { PlacementProtocolResult } from "./placement.js";
 import type { ProtocolProgress } from "./progress.js";
 import { type ContractDocumentProjection } from "./read/documents.js";
 import { type ContractBoard, type ContractCatalogue, type ContractObservation } from "./read/status.js";
-import type { ProtocolResult, ProtocolTerminal } from "./run.js";
+import type { ProtocolTerminal } from "./run.js";
 export { changeIdSchema, contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 export { entryUlidSchema } from "./attempt.js";
 export declare const gateSchema: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
 export declare const deliverDataSchema: 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>>;
@@ -29,6 +32,7 @@ export declare const deliverDataSchema: z.ZodObject<{
         requireBranchesToBeUpToDate: z.ZodBoolean;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare function recordedIntegrationSnapshots(journal: readonly JournalEntry[]): readonly SnapshotId[];
 export declare const verdictSchema: z.ZodEnum<{
     satisfied: "satisfied";
     unsatisfied: "unsatisfied";
@@ -70,6 +74,12 @@ export declare const verificationDeclarationRefusalSchema: z.ZodObject<{
     kind: z.ZodLiteral<"verification-declaration-invalid">;
     contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>>;
 }, z.core.$strict>;
+export declare const candidateContentChangeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"candidate-content-changed">;
+    target: z.ZodOptional<z.ZodString>;
+    previousChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+    currentChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+}, z.core.$strict>;
 export declare const gateReportSchema: z.ZodObject<{
     gate: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
     current: z.ZodUnion<readonly [z.ZodObject<{
@@ -399,19 +409,23 @@ export type MutationOperationInput = OperationInput & Readonly<{
     channel: GitDecodeChannel;
     progress?: ProtocolProgress;
 }>;
+/** The decision input of an intent whose verb contributes only its own payload. */
+type VoidIntentDecision<Payload extends object> = Payload & Readonly<{
+    contractId: ContractId;
+    actor?: ActorId;
+    at: string;
+}>;
+/**
+ * Observe, decide, and atomically admit one intent over the invoking actor and time, then complete it
+ * as a void outcome. The verb contributes only its own decision payload.
+ */
+export declare function admitVoidIntent<Payload extends object, Refusal>(input: MutationOperationInput, payload: Payload, decide: (input: DecideInput<VoidIntentDecision<Payload>>) => OfferDecision<Refusal>, options?: IntentAdmissionOptions<Refusal>): Promise<IntentOutcome<void, Refusal>>;
 export type DocumentDerivation = Readonly<{
     document: DocumentKey;
     bytes: string;
     title: string;
     verification: VerificationDeclarationPreparation;
 }>;
-type StepStop<R> = Readonly<{
-    refusal: R;
-    retry?: never;
-} | {
-    retry: IntentRetry;
-    refusal?: never;
-}>;
 export declare const verificationStopSchema: z.ZodUnion<readonly [z.ZodObject<{
     refusal: z.ZodUnion<readonly [z.ZodObject<{
         kind: z.ZodEnum<{
@@ -617,8 +631,6 @@ export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission
 }>;
 export declare function timestamp(): string;
 export declare function attemptDecisionWithSeatClose<Value, Refusal = IntentRefusal>(outcome: PrivateStateSeatOutcome<AttemptDecision<Value, Refusal>>): AttemptDecision<Value, Refusal>;
-export declare function mergeAdmissions(current: AcceptedProtocolStep, next: AcceptedProtocolStep): AcceptedProtocolStep;
-export declare function stepStop<Refusal>(result: ProtocolResult<Refusal>): StepStop<Refusal> | undefined;
 export declare function unpackVerificationOutcome(verification: VerificationResult): Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;

package/build/src/protocol/operations.js

@@ -4,14 +4,16 @@ import { gate } from "../core/facts/types.js";
 import { changeIdSchema, contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 import { integrationPreparationRefusalSchema, readDeliveryDiff } from "../git/integration.js";
 import { currentBranch, observeContractAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, concatenatePrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
+import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { repositoryAt } from "../git/repository.js";
 import { checkoutNotFollowableRefusalSchema } from "../git/target-placement.js";
 import { dirtyWorkspaceRefusalSchema, unmergedPathsRefusalSchema, worktreeMissingRefusalSchema, } from "../git/tender.js";
 import { conflictRecoverySchema, worktreeWorkspaceSchema } from "../git/workspace.js";
 import { forkSourceMovedRefusalSchema, targetInputRefusalSchema } from "./bind.js";
+import { admitIntent } from "./intent.js";
 import { verificationRuntimeStopSchema } from "./intent.js";
+import { complete } from "./outcome.js";
 import { readDocuments } from "./read/documents.js";
 import { readContractBoard, readContractCatalogue, readContractObservationAt, } from "./read/status.js";
 import { protocolTerminalSchema } from "./run.js";
@@ -28,6 +30,10 @@ export const gateSchema = z.string().transform((value, context) => {
 });
 export const deliverDataSchema = z
     .object({
+    note: z
+        .string()
+        .refine((value) => value.trim() !== "")
+        .optional(),
     tenderSnapshot: snapshotIdSchema,
     integration: z
         .object({ predecessor: snapshotIdSchema, snapshot: snapshotIdSchema, changeId: changeIdSchema })
@@ -36,6 +42,15 @@ export const deliverDataSchema = z
     policy: z.object({ requireBranchesToBeUpToDate: z.boolean() }).strict(),
 })
     .strict();
+export function recordedIntegrationSnapshots(journal) {
+    return journal
+        .flatMap((entry) => entry.kind === "deliver"
+        ? [entry.data.integration.snapshot]
+        : entry.kind === "reintegrated"
+            ? [entry.data.snapshot]
+            : [])
+        .reverse();
+}
 export const verdictSchema = z.enum(["satisfied", "unsatisfied"]);
 export const activeContractRefusalSchema = z
     .object({ kind: z.enum(["contract-missing", "terminal"]), contractId: contractIdSchema })
@@ -55,7 +70,7 @@ export const deliverRefusalSchema = z
 export const verificationDeclarationRefusalSchema = z
     .object({ kind: z.literal("verification-declaration-invalid"), contractId: contractIdSchema.optional() })
     .strict();
-const staleGateReasonSchema = z
+export const candidateContentChangeSchema = z
     .object({
     kind: z.literal("candidate-content-changed"),
     target: z.string().optional(),
@@ -72,7 +87,11 @@ export const gateReportSchema = z
             .object({ kind: z.literal("attested"), verdict: verdictSchema, at: z.string(), summary: z.string().optional() })
             .strict(),
         z
-            .object({ kind: z.literal("stale"), priorVerdict: verdictSchema, reason: staleGateReasonSchema.optional() })
+            .object({
+            kind: z.literal("stale"),
+            priorVerdict: verdictSchema,
+            reason: candidateContentChangeSchema.optional(),
+        })
             .strict(),
     ]),
 })
@@ -136,6 +155,19 @@ export const intentRefusalSchema = z.union([
     targetInputRefusalSchema,
     verificationDeclarationRefusalSchema,
 ]);
+/**
+ * Observe, decide, and atomically admit one intent over the invoking actor and time, then complete it
+ * as a void outcome. The verb contributes only its own decision payload.
+ */
+export async function admitVoidIntent(input, payload, decide, options) {
+    const decisionInput = {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+        ...payload,
+    };
+    return complete(await admitIntent(input.channel, input.scope, decisionInput, decide, options), undefined);
+}
 export const verificationStopSchema = z.union([
     z.object({ refusal: z.union([activeContractRefusalSchema, verificationDeclarationRefusalSchema]) }).strict(),
     z.object({ retry: protocolTerminalSchema }).strict(),
@@ -191,18 +223,7 @@ export function attemptDecisionWithSeatClose(outcome) {
         return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
     });
 }
-export function mergeAdmissions(current, next) {
-    const effects = [...(current.physical?.effects ?? []), ...(next.physical?.effects ?? [])];
-    const lag = [...(current.physical?.lag ?? []), ...(next.physical?.lag ?? [])];
-    const seatClose = concatenatePrivateStateSeatClose(current.seatClose, next.seatClose);
-    return {
-        ...next,
-        facts: [...current.facts, ...next.facts],
-        ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
-        ...(seatClose === undefined ? {} : { seatClose }),
-    };
-}
-export function stepStop(result) {
+function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;
     return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };

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

@@ -12,7 +12,7 @@ export type PlacementExecutionFailure = Readonly<{
     kind: "placement-failed";
     diagnostic: string;
 }>;
-export type TargetMovedStop = Readonly<{
+type TargetMovedStop = Readonly<{
     kind: "target-moved";
     contractId: ContractId;
     target: string;
@@ -20,6 +20,7 @@ export type TargetMovedStop = Readonly<{
     observed: SnapshotId | null;
     observedTreeEqualsCandidate: boolean;
 }>;
+export declare function observeIntegrationTargetMovement(repository: GitRepository, state: import("../core/facts/types.js").ContractState): Promise<TargetMovedStop | undefined>;
 export type PlacementProtocolResult<ExtraRefusal = never> = (AcceptedAdmission & Readonly<{
     physical?: ReconcileResult;
 }>) | Exclude<ProtocolResult<PlacementRefusal | TargetPlacementRefusal | ExtraRefusal>, AcceptedAdmission> | TargetMovedStop | PlacementExecutionFailure;

package/build/src/protocol/placement.js

@@ -10,6 +10,23 @@ import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacem
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { prepareProtocolAttempt, runProtocol } from "./run.js";
 export { observeTargetPlacement } from "../git/target-placement.js";
+export async function observeIntegrationTargetMovement(repository, state) {
+    const target = state.coordinates.target;
+    const integration = state.currentIntegration;
+    if (target === undefined || integration === null)
+        return undefined;
+    const observed = await observeTargetHead(repository, target);
+    if (observed === integration.predecessor)
+        return undefined;
+    return {
+        kind: "target-moved",
+        contractId: state.id,
+        target,
+        expected: integration.predecessor,
+        observed,
+        observedTreeEqualsCandidate: await observedTreeEqualsCandidate(repository, observed, integration.snapshot),
+    };
+}
 function placementFailure(error) {
     return { kind: "placement-failed", diagnostic: error instanceof Error ? error.message : String(error) };
 }
@@ -75,14 +92,13 @@ async function runFencedPlacement(repository, input, protocol) {
             if (physical.kind === "refused")
                 return physical;
             const admitted = await admitDecidedOffer({
-                channel: protocol.channel,
-                repository,
+                ...protocol,
+                scope: repository,
+                contractId: input.contractId,
                 seat,
-                decisionObservation: prepared.observation,
+                observation: prepared.observation,
                 attempt: prepared.attempt,
                 offer: prepared.offer,
-                primaryContract: input.contractId,
-                ...(protocol.progress === undefined ? {} : { progress: protocol.progress }),
             });
             if (admitted.kind === "accepted")
                 preparedPhysical = physical.placement;

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

@@ -50,7 +50,7 @@ export declare const executionCleanupSchema: z.ZodUnion<readonly [z.ZodObject<{
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
     snapshot: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
     leak: z.ZodObject<{
-        path: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
         diagnostic: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{