@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/protocol/amend.js

@@ -1,4 +1,5 @@
 import { extendContractsForAdmissionAt, observeContractsForAdmissionAt } from "../git/observe.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideAmend } from "../core/verbs/amend.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
@@ -24,56 +25,61 @@ async function extendPrerequisiteClosureAt(channel, observation, seeds) {
     return current;
 }
 export async function amendOperation(input) {
-    const attempts = mintAttempts({ entryCount: 1 });
     let source = input.source;
-    for (let index = 0; index < attempts.length; index += 1) {
-        let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-        const state = contractState(observation.decision, input.contractId);
-        if (source === undefined && state !== null)
-            source = state.terms;
-        const amendment = source === undefined || input.deriveAmendment === undefined
-            ? undefined
-            : { source, ...input.deriveAmendment(source) };
-        if (amendment !== undefined) {
-            observation = await extendPrerequisiteClosureAt(input.channel, observation, [
-                ...new Set([...(state?.terms.after ?? []), ...amendment.terms.after]),
-            ]);
-        }
-        const preparation = amendment === undefined
-            ? undefined
-            : amendment.verification.kind === "prepared"
-                ? { kind: "prepared", data: amendment.terms }
-                : { kind: "refused", refusal: amendment.verification.refusal };
-        const decision = decideAmend({
-            input: {
-                contractId: input.contractId,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                at: timestamp(),
-                ...(amendment === undefined ? {} : { source: amendment.source }),
-                ...(preparation === undefined ? {} : { preparation }),
-            },
-            attempt: attempts[index],
-            observation: observation.decision,
-        });
-        if (decision.kind === "refused")
-            return decision;
-        const admission = await admitDecidedOffer({
-            channel: input.channel,
-            repository: input.scope,
-            decisionObservation: observation,
-            attempt: attempts[index],
-            offer: decision.offer,
-            primaryContract: input.contractId,
-        });
-        if (admission.kind === "accepted") {
-            if (amendment === undefined)
-                throw new Error("accepted amendment is missing its document derivation");
-            return admitted(admission, amendment);
-        }
-        if (admission.kind === "publication-failed")
-            return { kind: "retry", reason: admission };
-        if (admission.kind === "collision" && index + 1 === attempts.length)
-            return { kind: "retry", reason: admission };
+    if (source === undefined) {
+        const initial = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+        source = contractState(initial.decision, input.contractId)?.terms;
     }
-    return { kind: "retry", reason: { kind: "exhausted" } };
+    return await withPrivateStatePublicationSeat(input.scope, async (seat) => {
+        const attempts = mintAttempts({ entryCount: 1 });
+        for (let index = 0; index < attempts.length; index += 1) {
+            let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+            const state = contractState(observation.decision, input.contractId);
+            const amendment = source === undefined || input.deriveAmendment === undefined
+                ? undefined
+                : { source, ...input.deriveAmendment(source) };
+            if (amendment !== undefined) {
+                observation = await extendPrerequisiteClosureAt(input.channel, observation, [
+                    ...new Set([...(state?.terms.after ?? []), ...amendment.terms.after]),
+                ]);
+            }
+            const preparation = amendment === undefined
+                ? undefined
+                : amendment.verification.kind === "prepared"
+                    ? { kind: "prepared", data: amendment.terms }
+                    : { kind: "refused", refusal: amendment.verification.refusal };
+            const decision = decideAmend({
+                input: {
+                    contractId: input.contractId,
+                    ...(input.actor === undefined ? {} : { actor: input.actor }),
+                    at: timestamp(),
+                    ...(amendment === undefined ? {} : { source: amendment.source }),
+                    ...(preparation === undefined ? {} : { preparation }),
+                },
+                attempt: attempts[index],
+                observation: observation.decision,
+            });
+            if (decision.kind === "refused")
+                return decision;
+            const admission = await admitDecidedOffer({
+                channel: input.channel,
+                repository: input.scope,
+                seat,
+                decisionObservation: observation,
+                attempt: attempts[index],
+                offer: decision.offer,
+                primaryContract: input.contractId,
+            });
+            if (admission.kind === "accepted") {
+                if (amendment === undefined)
+                    throw new Error("accepted amendment is missing its document derivation");
+                return admitted(admission, amendment);
+            }
+            if (admission.kind === "publication-failed")
+                return { kind: "retry", reason: admission };
+            if (admission.kind === "collision" && index + 1 === attempts.length)
+                return { kind: "retry", reason: admission };
+        }
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    });
 }

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

@@ -1,5 +1,6 @@
 import { type PublicationFailed } from "../git/admission.js";
 import { type GitDecisionObservation } from "../git/observe.js";
+import { type PrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type GitRefAssertion } from "../git/repository.js";
 import type { GitRepository } from "../git/process.js";
@@ -41,6 +42,7 @@ export type DecidedOfferResult<Refusal = never> = AcceptedAdmission | AttemptTer
 export declare function admitDecidedOffer<Refusal = never>(input: Readonly<{
     channel: GitDecodeChannel;
     repository: GitRepository;
+    seat: PrivateStatePublicationSeat;
     decisionObservation: GitDecisionObservation;
     attempt: AttemptContext;
     offer: Offer;

package/build/src/protocol/attempt.js

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { encodeEntry } from "../core/facts/codec.js";
 import { admit } from "../git/admission.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { confirmPrivateStatePublication } from "../git/private-state-seat.js";
 import { GIT_REF, readRefs } from "../git/repository.js";
 import { foldJournal } from "../core/facts/fold.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
@@ -103,6 +104,7 @@ export async function admitDecidedOffer(input) {
     }
     const admission = await admit(repository, offer, decisionObservation.admission, assertions);
     if (admission.kind === "accepted") {
+        confirmPrivateStatePublication(input.seat);
         return {
             kind: "accepted",
             facts: offerEntries(offer),
@@ -118,9 +120,14 @@ export async function admitDecidedOffer(input) {
     const recovered = await observeContractsForAdmissionAt(repository, channel, offer.facts.map((append) => append.contractId));
     const classification = classifyUnknownAttempt({ contracts: recovered.journals }, offer);
     if (classification.kind === "accepted")
-        return recoveredAcceptance({ contracts: recovered.journals }, offer, primaryContract);
+        return confirmRecoveredAcceptance(input.seat, { contracts: recovered.journals }, offer, primaryContract);
     return classification.kind === "collision" ? { kind: "collision" } : { kind: "redecide" };
 }
+function confirmRecoveredAcceptance(seat, observation, offer, primaryContract) {
+    const recovered = recoveredAcceptance(observation, offer, primaryContract);
+    confirmPrivateStatePublication(seat);
+    return recovered;
+}
 /** Classify an unknown atomic-publication outcome using only a captured Git observation. */
 export function classifyUnknownAttempt(observation, offer) {
     let exact = 0;

package/build/src/protocol/completion.js

@@ -135,6 +135,9 @@ export async function completeCandidate(input) {
     if (placement.kind !== "target-moved" || input.target === undefined) {
         return { admission, evidence: mergeEvidence(evidence, { placement: requiredPlacementStop(placement) }) };
     }
+    if (placement.observedTreeEqualsCandidate) {
+        return { admission, evidence: mergeEvidence(evidence, { placement: requiredPlacementStop(placement) }) };
+    }
     let integratedAt;
     for (let attempts = 1; attempts <= MAX_REINTEGRATION_CYCLES; attempts += 1) {
         const reintegrated = await reintegrateOperation({
@@ -161,6 +164,9 @@ export async function completeCandidate(input) {
         if (placement.kind !== "target-moved") {
             return { admission, evidence: mergeEvidence(evidence, { placement: requiredPlacementStop(placement) }) };
         }
+        if (placement.observedTreeEqualsCandidate) {
+            return { admission, evidence: mergeEvidence(evidence, { placement: requiredPlacementStop(placement) }) };
+        }
         if (attempts === MAX_REINTEGRATION_CYCLES) {
             return {
                 admission,
@@ -172,6 +178,7 @@ export async function completeCandidate(input) {
                         integratedAt: integratedAt,
                         observed: placement.observed,
                         attempts,
+                        observedTreeEqualsCandidate: placement.observedTreeEqualsCandidate,
                     },
                 }),
             };

package/build/src/protocol/deliver.js

@@ -2,6 +2,7 @@ import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegrat
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { worktreePath } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
@@ -11,7 +12,7 @@ import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 import { timestamp } from "./operations.js";
 const DELIVER_CONFLICT_RECOVERY = Object.freeze({
     materialize: "deliver --materialize-conflict",
-    continue: "deliver",
+    continue: "deliver --include-dirty",
 });
 export async function prepareDelivery(repository, stage, input) {
     const { contractId, coordinates } = stage;
@@ -25,7 +26,6 @@ export async function prepareDelivery(repository, stage, input) {
         coordinates,
         ...(appointed === undefined ? {} : { place: appointed.place }),
         captureMergeState: true,
-        rejectUnmerged: true,
     });
     if (tender.kind === "refused")
         return tender;
@@ -64,6 +64,9 @@ export async function prepareDelivery(repository, stage, input) {
     };
 }
 async function deliverAttempt(input, attempt) {
+    return await withPrivateStatePublicationSeat(input.scope, async (seat) => await deliverAttemptInPrivateStateSeat(input, attempt, seat));
+}
+async function deliverAttemptInPrivateStateSeat(input, attempt, seat) {
     const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(decisionObservation.decision, input.contractId);
     const derivation = state === null ? undefined : input.deriveDocument(state);
@@ -117,6 +120,7 @@ async function deliverAttempt(input, attempt) {
     const admission = await admitDecidedOffer({
         channel: input.channel,
         repository: input.scope,
+        seat,
         decisionObservation,
         attempt,
         offer: decision.offer,

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

@@ -41,7 +41,7 @@ export type DeliverConflictRefusal = Readonly<{
     conflictPaths: readonly string[];
     recovery: Readonly<{
         materialize: "deliver --materialize-conflict";
-        continue: "deliver";
+        continue: "deliver --include-dirty";
     }>;
 }>;
 export type DeliveryPreparationRefusal = Readonly<{
@@ -82,6 +82,7 @@ export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal |
     target: string;
     expected: SnapshotId;
     observed: SnapshotId | null;
+    observedTreeEqualsCandidate: boolean;
 }> | Readonly<{
     failure: "target-moved";
     contractId: ContractId;
@@ -89,6 +90,7 @@ export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal |
     integratedAt: SnapshotId;
     observed: SnapshotId | null;
     attempts: number;
+    observedTreeEqualsCandidate: boolean;
 }> | Readonly<{
     failure: "target-placement-failed";
     diagnostic: string;
@@ -117,6 +119,7 @@ export declare function unpackVerificationOutcome(verification: VerificationResu
 }>;
 export declare function placementStop(result: PlacementProtocolResult<IntegrationPreparationRefusal>): PlacementStop | undefined;
 export type RepositoryScope = GitRepository;
+export declare function withScopeAbortSignal(scope: RepositoryScope, signal: AbortSignal | undefined): RepositoryScope;
 export declare function scopeOperation(input: Readonly<{
     coordinate: string;
     gitPath?: string;

package/build/src/protocol/operations.js

@@ -39,11 +39,14 @@ export function placementStop(result) {
     if (result.kind === "placement-failed")
         return { failure: "target-placement-failed", diagnostic: result.diagnostic };
     if (result.kind === "target-moved") {
-        const { contractId, target, expected, observed } = result;
-        return { failure: "target-moved", contractId, target, expected, observed };
+        const { contractId, target, expected, observed, observedTreeEqualsCandidate } = result;
+        return { failure: "target-moved", contractId, target, expected, observed, observedTreeEqualsCandidate };
     }
     return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };
 }
+export function withScopeAbortSignal(scope, signal) {
+    return signal === undefined ? scope : { ...scope, signal };
+}
 export async function scopeOperation(input) {
     return await repositoryAt(input.coordinate, input.gitPath);
 }

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

@@ -16,6 +16,7 @@ export type TargetMovedStop = Readonly<{
     target: string;
     expected: SnapshotId;
     observed: SnapshotId | null;
+    observedTreeEqualsCandidate: boolean;
 }>;
 export type PlacementProtocolResult<ExtraRefusal = never> = (AcceptedAdmission & Readonly<{
     physical?: ReconcileResult;

package/build/src/protocol/placement.js

@@ -3,9 +3,10 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeGitForAdmissionAt } from "../git/observe.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
-import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } from "../git/target-placement.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, observedTreeEqualsCandidate, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { prepareProtocolAttempt, runProtocol } from "./run.js";
 function placementFailure(error) {
@@ -21,45 +22,58 @@ function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
 async function runFencedPlacement(repository, input, protocol) {
-    for (let index = 0; index < protocol.attempts.length; index += 1) {
-        const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
-        if (prepared.kind === "refused")
-            return prepared;
-        const state = contractState(prepared.observation.decision, input.contractId);
-        if (state === null)
-            throw new Error("placement offer has no contract state");
-        if (prepared.offer.target === undefined)
-            throw new Error("targeted placement offer is missing its target movement");
-        const observed = await observeTargetHead(repository, prepared.offer.target.target);
-        if (observed !== prepared.offer.target.expectedOid) {
-            return {
-                kind: "target-moved",
-                contractId: input.contractId,
-                target: prepared.offer.target.target,
-                expected: prepared.offer.target.expectedOid,
-                observed,
-            };
-        }
-        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
-        if (physical.kind === "refused")
-            return physical;
-        const result = await admitDecidedOffer({
-            channel: protocol.channel,
-            repository,
-            decisionObservation: prepared.observation,
-            attempt: prepared.attempt,
-            offer: prepared.offer,
-            primaryContract: input.contractId,
-        });
-        if (result.kind === "accepted") {
-            return { ...result, physical: await followTargetPlacement(repository, physical.placement) };
+    let preparedPhysical;
+    const result = await withPrivateStatePublicationSeat(repository, async (seat) => {
+        for (let index = 0; index < protocol.attempts.length; index += 1) {
+            const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
+            if (prepared.kind === "refused")
+                return prepared;
+            const state = contractState(prepared.observation.decision, input.contractId);
+            if (state === null)
+                throw new Error("placement offer has no contract state");
+            if (prepared.offer.target === undefined)
+                throw new Error("targeted placement offer is missing its target movement");
+            const observed = await observeTargetHead(repository, prepared.offer.target.target);
+            if (observed !== prepared.offer.target.expectedOid) {
+                const treeEquals = await observedTreeEqualsCandidate(repository, observed, prepared.offer.target.newOid);
+                return {
+                    kind: "target-moved",
+                    contractId: input.contractId,
+                    target: prepared.offer.target.target,
+                    expected: prepared.offer.target.expectedOid,
+                    observed,
+                    observedTreeEqualsCandidate: treeEquals,
+                };
+            }
+            const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
+            if (physical.kind === "refused")
+                return physical;
+            const result = await admitDecidedOffer({
+                channel: protocol.channel,
+                repository,
+                seat,
+                decisionObservation: prepared.observation,
+                attempt: prepared.attempt,
+                offer: prepared.offer,
+                primaryContract: input.contractId,
+            });
+            if (result.kind === "accepted") {
+                preparedPhysical = physical.placement;
+                return result;
+            }
+            if (result.kind === "publication-failed")
+                return result;
+            if (result.kind === "collision" && index + 1 === protocol.attempts.length)
+                return result;
         }
-        if (result.kind === "publication-failed")
-            return result;
-        if (result.kind === "collision" && index + 1 === protocol.attempts.length)
-            return result;
+        return { kind: "exhausted" };
+    });
+    if (result.kind !== "accepted")
+        return result;
+    if (preparedPhysical === undefined) {
+        throw new Error("accepted placement has no prepared target checkout");
     }
-    return { kind: "exhausted" };
+    return { ...result, physical: await followTargetPlacement(repository, preparedPhysical) };
 }
 /** Hold the existing target-placement fence for one owner callback. */
 export async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {

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

@@ -1,11 +1,8 @@
 import type { GitRepository } from "../../git/process.js";
 import type { ContractRow } from "./status.js";
 export type CurrentPhysicalIssue = Readonly<{
-    kind: "hook-failure";
-    diagnostic: string;
-}> | Readonly<{
     kind: "target-checkout-retained";
     target: string;
 }>;
-/** Selected-only pure projection of durable hook failure or retained target checkout. */
+/** Selected-only pure projection of retained target checkout state. */
 export declare function observeCurrentPhysicalIssue(repository: GitRepository, row: ContractRow): Promise<CurrentPhysicalIssue | undefined>;

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

@@ -1,20 +1,7 @@
-import { observeWorktreeHookMarker } from "../../git/hooks.js";
-import { registeredWorktrees, worktreeGitDirectory } from "../../git/repository.js";
+import { registeredWorktrees } from "../../git/repository.js";
 import { observeTargetCheckoutShape } from "../../git/target-placement.js";
-function appointedWorkspacePath(row) {
-    const observation = row.workspaceObservation;
-    if (observation.kind !== "clean" && observation.kind !== "dirty")
-        return null;
-    return observation.location.kind === "worktree" ? observation.location.path : null;
-}
-/** Selected-only pure projection of durable hook failure or retained target checkout. */
+/** Selected-only pure projection of retained target checkout state. */
 export async function observeCurrentPhysicalIssue(repository, row) {
-    const workspacePath = appointedWorkspacePath(row);
-    if (workspacePath !== null) {
-        const marker = await observeWorktreeHookMarker(await worktreeGitDirectory(repository, workspacePath));
-        if (marker.kind === "failed")
-            return { kind: "hook-failure", diagnostic: marker.diagnostic };
-    }
     const target = row.target;
     const delivery = row.delivery;
     if (row.phase !== "claimed" || target === null || delivery === null)

package/build/src/protocol/reintegrate.js

@@ -2,72 +2,76 @@ import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { timestamp } from "./operations.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
 async function runReintegration(input) {
-    const attempts = mintAttempts({ entryCount: 1 });
-    for (let index = 0; index < attempts.length; index += 1) {
-        const attempt = attempts[index];
-        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);
+    return 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 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: "prepared",
-                    data: { predecessor: planned.data.predecessor, snapshot },
+                    kind: "refused",
+                    refusal: {
+                        kind: state === null ? "contract-missing" : "delivery-missing",
+                        contractId: input.contractId,
+                    },
                 };
-                assertions = [{ ref: input.target, oid: planned.data.predecessor }];
             }
+            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 decision = decideReintegrate({
+                input: {
+                    contractId: input.contractId,
+                    ...(input.actor === undefined ? {} : { actor: input.actor }),
+                    at: timestamp(),
+                    preparation,
+                },
+                attempt,
+                observation: observation.decision,
+            });
+            if (decision.kind === "refused")
+                return { kind: "refused", refusal: decision.refusal };
+            const result = await admitDecidedOffer({
+                channel: input.channel,
+                repository: input.repository,
+                seat,
+                decisionObservation: observation,
+                attempt,
+                offer: decision.offer,
+                primaryContract: input.contractId,
+                assertions,
+            });
+            if (result.kind === "accepted") {
+                if (preparation.kind !== "prepared")
+                    throw new Error("accepted reintegration has no preparation");
+                return { ...result, value: preparation.data };
+            }
+            if (result.kind === "publication-failed")
+                return { kind: "retry", reason: result };
+            if (result.kind === "collision" && index + 1 === attempts.length)
+                return { kind: "retry", reason: result };
         }
-        const decision = decideReintegrate({
-            input: {
-                contractId: input.contractId,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                at: timestamp(),
-                preparation,
-            },
-            attempt,
-            observation: observation.decision,
-        });
-        if (decision.kind === "refused")
-            return { kind: "refused", refusal: decision.refusal };
-        const result = await admitDecidedOffer({
-            channel: input.channel,
-            repository: input.repository,
-            decisionObservation: observation,
-            attempt,
-            offer: decision.offer,
-            primaryContract: input.contractId,
-            assertions,
-        });
-        if (result.kind === "accepted") {
-            if (preparation.kind !== "prepared")
-                throw new Error("accepted reintegration has no preparation");
-            return { ...result, value: preparation.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 { 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/review.js

@@ -1,6 +1,7 @@
 import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
@@ -53,6 +54,9 @@ function reviewValue(value, completion = {}) {
     };
 }
 async function reviewAttempt(input, attempt) {
+    return await withPrivateStatePublicationSeat(input.scope, async (seat) => await reviewAttemptInPrivateStateSeat(input, attempt, seat));
+}
+async function reviewAttemptInPrivateStateSeat(input, attempt, seat) {
     const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(decisionObservation.decision, input.contractId);
     let preparation;
@@ -98,6 +102,7 @@ async function reviewAttempt(input, attempt) {
     const admission = await admitDecidedOffer({
         channel: input.channel,
         repository: input.scope,
+        seat,
         decisionObservation,
         attempt,
         offer: decision.offer,