@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/protocol/operations.js

@@ -1,126 +1,288 @@
-import { prepareDelivery, prepareReview, } from "../git/delivery.js";
-import { currentBranch, extendContractsForAdmission, observeGit, observeContract, observeContractsForAdmission, } from "../git/observe.js";
-import { reconcile, reconcileBatch, reconcileObservationFailure } from "../git/reconcile.js";
+import { materializeIntegrationSnapshot, planIntegration, readDeliveryDiff, readDeliveryScope, worktreeChangeId, } from "../git/integration.js";
+import { captureTender, dirtyTenderDelta, dirtyTenderRefusal, materializeTenderSnapshot, } from "../git/tender.js";
+import { currentBranch, extendContractsForAdmissionAt, observeContractAt, observeContractWorld, observeContractsForAdmissionAt, } from "../git/observe.js";
+import { reconcile, reconcileBatch, reconcileObservationFailure, } from "../git/reconcile.js";
 import { NoGitWorldError, repositoryAt } from "../git/repository.js";
-import { readDeliveryDiff } from "../git/verification.js";
+import { withGitReadObservation } from "../git/read-observation.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { contractState, documentIsCurrent } from "../core/facts/observation.js";
+import { activeContract, contractState, documentIsCurrent } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
 import { decideAbandon } from "../core/verbs/abandon.js";
 import { decideAmend } from "../core/verbs/amend.js";
 import { decideArc } from "../core/verbs/arc.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
-import { produceVerification } from "../verification/producer.js";
-import { admitIntent, admitPlacement, mintAttempts, verifyDelivery } from "./intent.js";
-import { auditReport, readAudit } from "./read/audit.js";
+import { admitIntent, currentVerifiedAttestation, verifyDelivery, } from "./intent.js";
+import { admitPlacement, } from "./placement.js";
+import { adjudicateAuditTarget } from "../git/target-placement.js";
 import { readDocuments } from "./read/documents.js";
-import { readContractBoard, readContractObservation, } from "./read/status.js";
-import { admitDecidedOffer } from "./attempt.js";
+import { readContractBoard, readContractObservationAt, } from "./read/status.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { appointmentFor, readManagedWorktreeAppointment, readPlaceRegister, } from "../workspace-place.js";
 export { bindOperation } from "./bind.js";
-import { accepted, admitted, complete } from "./outcome.js";
+export { reconcileObservationFailure } from "../git/reconcile.js";
+import { accepted, admitted, complete, } from "./outcome.js";
 const REVIEWED = gate("reviewed");
 function timestamp() { return new Date().toISOString(); }
 function mergeAdmissions(current, next) {
-    return { ...next, facts: [...current.facts, ...next.facts] };
+    const effects = [...(current.physical?.effects ?? []), ...(next.physical?.effects ?? [])];
+    const lag = [...(current.physical?.lag ?? []), ...(next.physical?.lag ?? [])];
+    return {
+        ...next,
+        facts: [...current.facts, ...next.facts],
+        ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+    };
 }
 function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;
     return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };
 }
+function verificationStop(step) {
+    return "failure" in step ? step : stepStop(step);
+}
+function unpackVerificationOutcome(verification) {
+    const stop = verificationStop(verification.step);
+    const admission = !("failure" in verification.step) && verification.step.kind === "accepted"
+        ? verification.step
+        : undefined;
+    return {
+        ...(verification.cleanup === undefined ? {} : { cleanup: verification.cleanup }),
+        ...(verification.leak === undefined ? {} : { leak: verification.leak }),
+        ...(stop === undefined ? {} : { stop }),
+        ...(admission === undefined ? {} : { admission }),
+        ...(verification.counts === undefined ? {} : { counts: verification.counts }),
+    };
+}
+function placementStop(result) {
+    if (result.kind === "accepted")
+        return undefined;
+    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 };
+    }
+    return result.kind === "refused" ? { refusal: result.refusal } : { retry: result };
+}
 export { NoGitWorldError };
-export function scopeOperation(input) { return repositoryAt(input.coordinate); }
-export function currentBranchOperation(input) {
-    return currentBranch(input.scope);
+export async function scopeOperation(input) {
+    return await repositoryAt(input.coordinate);
+}
+export async function currentBranchOperation(input) {
+    return await currentBranch(input.scope);
+}
+export async function contractsOperation(input) {
+    return withGitReadObservation(input.scope, input.channel, readContractBoard);
 }
-export function contractsOperation(input) { return readContractBoard(input.scope); }
-export function contractObservationOperation(input) {
-    return readContractObservation(input.scope, input.contractId);
+export async function contractObservationOperation(input) {
+    return await readContractObservationAt(input.scope, input.channel, input.contractId);
 }
-export function documentsOperation(input) { return readDocuments(input.scope); }
-export function stateOperation(input) {
-    const state = observeContract(input.scope, input.contractId).state;
+export async function documentsOperationAt(scope, channel) {
+    return withGitReadObservation(scope, channel, readDocuments);
+}
+export async function stateOperation(input) {
+    const state = (await observeContractAt(input.scope, input.channel, input.contractId)).state;
     if (state === null)
         throw new Error(`contract does not exist: ${input.contractId}`);
     return state;
 }
-export function readStateOperation(input) { return observeContract(input.scope, input.contractId).state; }
-export function deliveryOperation(input) {
-    const state = observeContract(input.scope, input.contractId).state;
-    if (state === null || state.delivery === null)
-        return null;
+export async function deliveryOperation(input) {
+    const state = (await observeContractAt(input.scope, input.channel, input.contractId)).state;
+    return state?.delivery?.data ?? null;
+}
+export async function deliveryDiffOperation(input) { return await readDeliveryDiff(input.scope, input.integrationPredecessor, input.integrationSnapshot); }
+async function extendPrerequisiteClosureAt(channel, observation, seeds) {
+    let current = observation;
+    const visited = new Set();
+    let pending = [...seeds];
+    while (pending.length > 0) {
+        const batch = [...new Set(pending.filter((id) => !visited.has(id)))];
+        pending = [];
+        if (batch.length === 0)
+            break;
+        current = await extendContractsForAdmissionAt(channel, current, batch);
+        for (const id of batch) {
+            visited.add(id);
+            const state = contractState(current.decision, id);
+            if (state !== null)
+                pending.push(...state.terms.after);
+        }
+    }
+    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 };
+    }
+    return { kind: "retry", reason: { kind: "exhausted" } };
+}
+export async function prepareDelivery(repository, stage, input) {
+    const { contractId, coordinates } = stage;
+    if (coordinates.workspace === "here" && coordinates.target !== undefined) {
+        const branch = await currentBranch(repository);
+        if (branch !== coordinates.target) {
+            return { kind: "refused", refusal: { kind: "workspace-not-on-target", contractId, target: coordinates.target, branch } };
+        }
+    }
+    const appointed = coordinates.workspace === "worktree"
+        ? stage.appointment === undefined
+            ? appointmentFor(await readPlaceRegister(repository), contractId)
+            : { contract: contractId, place: stage.appointment.place }
+        : undefined;
+    const tender = await captureTender(repository, {
+        contractId,
+        coordinates,
+        ...(appointed === undefined ? {} : { place: appointed.place }),
+    });
+    if (tender.kind === "refused")
+        return tender;
+    if ((tender.data.dirty && input.includeDirty !== true) || tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
+    }
+    const tenderSnapshot = await materializeTenderSnapshot(repository, tender.data, {
+        contractId,
+        title: input.title,
+        ...(input.message === undefined ? {} : { message: input.message }),
+    });
+    const requireBranchesToBeUpToDate = input.requireBranchesToBeUpToDate ?? false;
+    const integration = await planIntegration(repository, { contractId, coordinates }, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
+    if (integration.kind === "refused")
+        return integration;
+    const integrationSnapshot = coordinates.target === undefined
+        ? tenderSnapshot
+        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, {
+            contractId,
+            title: input.title,
+            ...(input.message === undefined ? {} : { message: input.message }),
+        });
     return {
-        snapshotId: state.delivery.data.candidate,
-        changeId: state.delivery.data.deliveryPatchId,
-        expectedPredecessor: state.delivery.data.expectedPredecessor,
+        kind: "prepared",
+        data: {
+            tenderSnapshot,
+            integration: {
+                predecessor: integration.data.predecessor,
+                snapshot: integrationSnapshot,
+                changeId: await worktreeChangeId(repository, { contractId, coordinates }, tender.data),
+            },
+            method: "squash",
+            policy: { requireBranchesToBeUpToDate },
+        },
     };
 }
-function observePrerequisiteClosure(repository, contracts) {
-    let observation = observeContractsForAdmission(repository, contracts);
-    let frontier = contracts.slice(1);
-    while (frontier.length > 0) {
-        const next = new Set();
-        for (const id of frontier) {
-            const state = contractState(observation.decision, id);
-            if (state === null)
-                continue;
-            for (const dependency of state.terms.after) {
-                if (!observation.decision.has(dependency))
-                    next.add(dependency);
-            }
-        }
-        frontier = [...next];
-        observation = extendContractsForAdmission(repository, observation, frontier);
+async function captureReviewableWorktree(repository, stage) {
+    const appointed = stage.coordinates.workspace === "worktree"
+        ? appointmentFor(await readPlaceRegister(repository), stage.contractId)
+        : undefined;
+    const tender = await captureTender(repository, {
+        ...stage,
+        ...(appointed === undefined ? {} : { place: appointed.place }),
+    });
+    if (tender.kind === "refused")
+        return tender;
+    if (tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, stage.contractId, tender.data) };
     }
-    return observation;
+    const workspace = await dirtyTenderDelta(repository, tender.data);
+    return {
+        kind: "prepared",
+        data: {
+            changeId: await worktreeChangeId(repository, stage, tender.data),
+            tender: tender.data,
+            ...(workspace === undefined ? {} : { workspace }),
+        },
+    };
 }
-export async function deliveryDiffOperation(input) { return readDeliveryDiff(input.scope, input.expectedPredecessor, input.snapshotId); }
-export function amendOperation(input) {
-    const amendment = input.amendment;
-    const preparation = amendment === undefined
-        ? undefined
-        : amendment.verification.kind === "prepared"
-            ? { kind: "prepared", data: amendment.terms }
-            : { kind: "refused", refusal: amendment.verification.refusal };
-    const decisionInput = {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        ...(amendment === undefined ? {} : { source: amendment.source }),
-        ...(preparation === undefined ? {} : { preparation }),
+export async function prepareReview(repository, stage) {
+    const prepared = await captureReviewableWorktree(repository, stage);
+    if (prepared.kind === "refused")
+        return prepared;
+    return {
+        kind: "prepared",
+        data: {
+            changeId: prepared.data.changeId,
+            ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
+        },
     };
-    return complete(admitIntent(input.scope, decisionInput, decideAmend, {
-        observedContracts: [input.contractId, ...(amendment?.terms.after ?? [])],
-        observe: observePrerequisiteClosure,
-    }), undefined);
 }
-function deliverAttempt(input, attempt) {
-    const decisionObservation = observeContractsForAdmission(input.scope, [input.contractId]);
+async function deliverAttempt(input, attempt) {
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(decisionObservation.decision, input.contractId);
+    const derivation = state === null || input.deriveDocument === undefined
+        ? undefined
+        : input.deriveDocument(state);
     let preparation;
-    if (state === null || input.derivation === undefined) {
+    if (state === null || derivation === undefined) {
         preparation = { kind: "unavailable" };
     }
-    else if (input.derivation.verification.kind === "refused") {
+    else if (derivation.verification.kind === "refused") {
         preparation = {
             kind: "refused",
-            document: input.derivation.document,
-            refusal: input.derivation.verification.refusal,
+            document: derivation.document,
+            refusal: derivation.verification.refusal,
         };
     }
     else {
-        const prepared = prepareDelivery(input.scope, {
+        const prepared = await prepareDelivery(input.scope, {
             contractId: state.id,
             coordinates: state.coordinates,
         }, {
-            title: input.derivation.title,
+            title: derivation.title,
             ...(input.message === undefined ? {} : { message: input.message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
         });
         preparation = prepared.kind === "refused"
-            ? { kind: "refused", document: input.derivation.document, refusal: prepared.refusal }
-            : { kind: "prepared", document: input.derivation.document, data: prepared.data };
+            ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
+            : { kind: "prepared", document: derivation.document, data: prepared.data };
     }
     const decisionInput = {
         contractId: input.contractId,
@@ -134,61 +296,73 @@ function deliverAttempt(input, attempt) {
     if (preparation.kind !== "prepared") {
         throw new Error("offered delivery is missing its mechanical preparation");
     }
-    const admitted = admitDecidedOffer(input.scope, decisionObservation, attempt, decision.offer, input.contractId);
+    const admitted = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
     if (admitted.kind === "accepted") {
-        return { ...admitted, value: {
-                snapshotId: preparation.data.candidate,
-                changeId: preparation.data.deliveryPatchId,
-                expectedPredecessor: preparation.data.expectedPredecessor,
-            } };
+        if (derivation === undefined)
+            throw new Error("accepted delivery is missing its document derivation");
+        return { ...admitted, value: { delivery: preparation.data, derivation } };
     }
     return admitted;
 }
 async function completeDelivery(input, first) {
-    if (input.derivation === undefined) {
-        throw new Error("accepted delivery is missing its document derivation");
-    }
-    const derivation = input.derivation;
+    const derivation = first.value.derivation;
     if (derivation.verification.kind !== "prepared") {
         throw new Error("accepted delivery is missing its Verification preparation");
     }
     let admission = first;
     let verificationValue;
+    let verificationReuse;
+    let cleanup;
     let leak;
-    const verification = await verifyDelivery({
-        repository: input.scope,
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        state: first.state,
-        environment: process.env,
-        produce: produceVerification,
-        ...(derivation.verification.data === null
-            ? {}
-            : { verification: derivation.verification.data }),
-    });
-    if (verification !== null) {
-        leak = verification.leak;
-        if ("failure" in verification.step)
-            verificationValue = verification.step;
-        else {
-            verificationValue = stepStop(verification.step);
-            if (verification.step.kind === "accepted")
-                admission = mergeAdmissions(admission, verification.step);
+    const currentVerified = currentVerifiedAttestation(first.state);
+    if (currentVerified !== undefined) {
+        verificationReuse = currentVerified;
+    }
+    else {
+        const verification = await verifyDelivery({
+            channel: input.channel,
+            repository: input.scope,
+            contractId: input.contractId,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            at: timestamp(),
+            state: first.state,
+            snapshot: first.value.delivery.integration.snapshot,
+            environment: process.env,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(derivation.verification.data === null
+                ? {}
+                : { verification: derivation.verification.data }),
+        });
+        if (verification !== null) {
+            const unpacked = unpackVerificationOutcome(verification);
+            cleanup = unpacked.cleanup;
+            leak = unpacked.leak;
+            verificationValue = unpacked.stop;
+            if (unpacked.admission !== undefined)
+                admission = mergeAdmissions(admission, unpacked.admission);
         }
     }
-    const placement = admitPlacement(input.scope, {
+    const placement = await admitPlacement(input.channel, input.scope, first.state.coordinates.target, {
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
     });
-    const placementValue = stepStop(placement);
+    const placementValue = placementStop(placement);
     if (placement.kind === "accepted")
         admission = mergeAdmissions(admission, placement);
     return admitted(admission, {
-        ...first.value,
+        ...first.value.delivery,
         ...(verificationValue === undefined ? {} : { verification: verificationValue }),
+        ...(verificationReuse === undefined ? {} : { verificationReuse }),
         ...(placementValue === undefined ? {} : { placement: placementValue }),
+        ...(cleanup === undefined ? {} : { cleanup }),
         ...(leak === undefined ? {} : { leak }),
     });
 }
@@ -196,7 +370,7 @@ export async function deliverOperation(input) {
     const attempts = mintAttempts({ entryCount: 2 });
     let first = null;
     for (let index = 0; index < attempts.length; index += 1) {
-        const result = deliverAttempt(input, attempts[index]);
+        const result = await deliverAttempt(input, attempts[index]);
         if (result.kind === "accepted") {
             first = result;
             break;
@@ -212,30 +386,41 @@ export async function deliverOperation(input) {
     }
     if (first === null)
         return { kind: "retry", reason: { kind: "exhausted" } };
-    return completeDelivery(input, first);
+    return await completeDelivery(input, first);
 }
-export function abandonOperation(input) {
-    return complete(admitIntent(input.scope, {
+export async function abandonOperation(input) {
+    return complete(await admitIntent(input.channel, input.scope, {
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
         ...(input.note === undefined ? {} : { note: input.note }),
-    }, decideAbandon, input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }), undefined);
+    }, decideAbandon, {
+        ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
+        ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
+    }), undefined);
 }
-export function arcOperation(input) {
-    return complete(admitIntent(input.scope, {
+export async function arcOperation(input) {
+    return complete(await admitIntent(input.channel, input.scope, {
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
         data: input.chapter,
     }, decideArc), undefined);
 }
-function reviewAttempt(input, attempt) {
-    const decisionObservation = observeContractsForAdmission(input.scope, [input.contractId]);
+function reviewValue(value, placement) {
+    return {
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...(placement === undefined ? {} : { placement }),
+    };
+}
+async function reviewAttempt(input, attempt) {
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(decisionObservation.decision, input.contractId);
     let preparation;
+    let workspace;
+    let tender;
     if (state !== null) {
-        const prepared = prepareReview(input.scope, { contractId: state.id, coordinates: state.coordinates });
+        const prepared = await captureReviewableWorktree(input.scope, { contractId: state.id, coordinates: state.coordinates });
         preparation = prepared.kind === "refused"
             ? { kind: "refused", refusal: prepared.refusal }
             : {
@@ -244,12 +429,16 @@ function reviewAttempt(input, attempt) {
                     gate: REVIEWED,
                     subject: dependencyKeySet([
                         { kind: "document", value: state.terms.document.key },
-                        { kind: "change", value: prepared.data },
+                        { kind: "change", value: prepared.data.changeId },
                     ]),
                     verdict: input.verdict,
                     ...(input.summary === undefined ? {} : { summary: input.summary }),
                 },
             };
+        if (prepared.kind === "prepared") {
+            workspace = prepared.data.workspace;
+            tender = prepared.data.tender;
+        }
     }
     const decisionInput = {
         contractId: input.contractId,
@@ -260,17 +449,30 @@ function reviewAttempt(input, attempt) {
     const decision = decideAttestation({ input: decisionInput, attempt, observation: decisionObservation.decision });
     if (decision.kind === "refused")
         return { kind: "refused", refusal: decision.refusal };
-    const admitted = admitDecidedOffer(input.scope, decisionObservation, attempt, decision.offer, input.contractId);
+    const admitted = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
     if (admitted.kind === "accepted")
-        return { ...admitted, value: undefined };
+        return {
+            ...admitted,
+            value: {
+                ...(workspace === undefined ? {} : { workspace }),
+                ...(tender === undefined ? {} : { tender }),
+            },
+        };
     return admitted;
 }
-export function reviewOperation(input) {
+export async function reviewOperation(input) {
     const git = input.scope;
-    const attempts = mintAttempts({ entryCount: 2 });
+    const attempts = mintAttempts({ entryCount: 1 });
     let review = null;
     for (let index = 0; index < attempts.length; index += 1) {
-        const result = reviewAttempt(input, attempts[index]);
+        const result = await reviewAttempt(input, attempts[index]);
         if (result.kind === "accepted" || result.kind === "refused") {
             review = result;
             break;
@@ -285,73 +487,178 @@ export function reviewOperation(input) {
     if (review.kind !== "accepted")
         return review;
     if (input.verdict !== "satisfied")
-        return admitted(review, {});
-    const placement = admitPlacement(git, {
+        return admitted(review, reviewValue(review.value));
+    const target = review.state.coordinates.target;
+    const tender = review.value.tender;
+    const placement = await admitPlacement(input.channel, git, target, {
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
+    }, tender === undefined || target === undefined ? undefined : async () => {
+        const integration = await planIntegration(git, {
+            contractId: input.contractId,
+            coordinates: review.state.coordinates,
+        }, tender, false);
+        if (integration.kind === "refused" && integration.refusal.kind !== "target-missing") {
+            return { kind: "refused", refusal: integration.refusal };
+        }
+        return undefined;
     });
-    const placementStop = stepStop(placement);
+    const stopped = placementStop(placement);
     const admission = placement.kind === "accepted" ? mergeAdmissions(review, placement) : review;
-    return admitted(admission, placementStop === undefined ? {} : { placement: placementStop });
+    return admitted(admission, reviewValue(review.value, stopped));
 }
-export async function auditOperation(input) {
-    const git = input.scope;
-    const initial = readAudit(git, input.contractId, REVIEWED);
-    if (initial.state === null)
-        return { kind: "refused", refusal: { kind: "contract-missing", contractId: input.contractId } };
-    const derivation = input.derivation;
-    if (derivation === undefined) {
-        return { kind: "refused", refusal: { kind: "document-moved", contractId: input.contractId } };
-    }
-    if (!documentIsCurrent(initial.state, derivation.document)) {
-        return { kind: "refused", refusal: { kind: "document-moved", contractId: input.contractId } };
-    }
-    if (derivation.verification.kind === "refused") {
-        return { kind: "refused", refusal: derivation.verification.refusal };
-    }
-    if (initial.state.delivery === null || derivation.verification.data === null) {
-        return accepted(initial.state, [], initial.report);
+async function auditWorkspace(repository, state) {
+    if (state.coordinates.workspace === "here") {
+        return { kind: "ready", answer: { kind: "here", path: repository.effectiveCwd } };
     }
+    const appointed = await readManagedWorktreeAppointment(repository, state.id);
+    if (appointed.kind === "failed")
+        throw new Error(appointed.diagnostic);
+    if (appointed.kind === "unappointed")
+        return appointed;
+    return {
+        kind: "ready",
+        answer: { kind: "worktree", path: appointed.path },
+        appointment: appointed,
+    };
+}
+function auditDeliveryRelation(state, candidate) {
+    const recorded = state.delivery?.data.integration.changeId;
+    if (recorded === undefined)
+        return undefined;
+    return {
+        changeId: recorded,
+        relation: recorded === candidate.integration.changeId ? "identical" : "differs",
+    };
+}
+async function auditCandidateVerification(input, state, snapshot, definition) {
     const verification = await verifyDelivery({
-        repository: git,
+        channel: input.channel,
+        repository: input.scope,
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
-        state: initial.state,
+        state,
+        snapshot,
         environment: process.env,
-        produce: produceVerification,
-        verification: derivation.verification.data,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        verification: definition,
     });
     if (verification === null) {
         throw new Error("audit verification preparation unexpectedly produced no attempt");
     }
-    const attempt = "failure" in verification.step
-        ? verification.step
-        : verification.step.kind === "accepted"
-            ? undefined
-            : verification.step.kind === "refused"
-                ? { refusal: verification.step.refusal }
-                : { retry: verification.step };
-    const report = !("failure" in verification.step) && verification.step.kind === "accepted"
-        ? auditReport(verification.step.journal, REVIEWED)
-        : initial.report;
+    return unpackVerificationOutcome(verification);
+}
+function auditVerificationAnswer(verified) {
+    if (verified === undefined)
+        return { kind: "not-run" };
+    if (verified.stop !== undefined)
+        return { kind: "stopped", stop: verified.stop };
+    if (verified.counts === undefined) {
+        throw new Error("terminal Verification is missing producer counts");
+    }
+    return {
+        kind: verified.counts.verdict,
+        passed: verified.counts.passed,
+        total: verified.counts.total,
+        ...(verified.counts.summary === undefined ? {} : { summary: verified.counts.summary }),
+    };
+}
+async function readyAuditCandidate(repository, candidate, workspace, showDiff) {
+    const predecessor = candidate.integration.predecessor;
+    const snapshot = candidate.integration.snapshot;
+    const scope = await readDeliveryScope(repository, predecessor, snapshot, showDiff);
+    const diff = showDiff ? await readDeliveryDiff(repository, predecessor, snapshot) : undefined;
+    return {
+        kind: "ready",
+        workspace,
+        identity: candidate,
+        scope,
+        ...(diff === undefined || diff === null ? {} : { diff }),
+    };
+}
+async function auditTargetAnswer(repository, state, candidate) {
+    const target = state.coordinates.target;
+    if (target === undefined)
+        return { kind: "not-observed" };
+    return await adjudicateAuditTarget(repository, {
+        contractId: state.id,
+        coordinates: { ...state.coordinates, target },
+        predecessor: candidate.integration.predecessor,
+        candidate: candidate.integration.snapshot,
+    });
+}
+export async function auditOperation(input) {
+    const observed = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = activeContract(observed.decision, input.contractId);
+    if ("kind" in state)
+        return { kind: "refused", refusal: state };
+    const derivation = input.deriveDocument?.(state);
+    if (derivation === undefined || !documentIsCurrent(state, derivation.document)) {
+        return { kind: "refused", refusal: { kind: "document-moved", contractId: input.contractId } };
+    }
+    if (derivation.verification.kind === "refused") {
+        return { kind: "refused", refusal: derivation.verification.refusal };
+    }
+    const workspace = await auditWorkspace(input.scope, state);
+    if (workspace.kind === "unappointed") {
+        return accepted(state, [], {
+            candidate: { kind: "blocked", refusal: { kind: "worktree-missing", contractId: state.id } },
+            verification: { kind: "not-run" },
+            target: { kind: "not-observed" },
+        });
+    }
+    const prepared = await prepareDelivery(input.scope, {
+        contractId: state.id,
+        coordinates: state.coordinates,
+        ...(workspace.appointment === undefined ? {} : { appointment: workspace.appointment }),
+    }, {
+        title: derivation.title,
+        requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate ?? false,
+        includeDirty: input.includeDirty ?? false,
+    });
+    if (prepared.kind === "refused") {
+        return accepted(state, [], {
+            candidate: { kind: "blocked", refusal: prepared.refusal },
+            verification: { kind: "not-run" },
+            target: { kind: "not-observed" },
+        });
+    }
+    const verified = derivation.verification.data === null
+        ? undefined
+        : await auditCandidateVerification(input, state, prepared.data.integration.snapshot, derivation.verification.data);
+    const delivery = auditDeliveryRelation(state, prepared.data);
+    const verification = auditVerificationAnswer(verified);
     const value = {
-        ...report,
-        ...(attempt === undefined ? {} : { attempt }),
-        ...(verification.leak === undefined ? {} : { leak: verification.leak }),
+        candidate: await readyAuditCandidate(input.scope, prepared.data, workspace.answer, input.showDiff === true),
+        verification,
+        target: verification.kind === "stopped"
+            ? { kind: "not-observed" }
+            : await auditTargetAnswer(input.scope, state, prepared.data),
+        ...(delivery === undefined ? {} : { delivery }),
     };
-    return !("failure" in verification.step) && verification.step.kind === "accepted"
-        ? admitted(verification.step, value)
-        : accepted(initial.state, [], value);
+    const obligations = {
+        ...(verified?.cleanup === undefined ? {} : { cleanup: verified.cleanup }),
+        ...(verified?.leak === undefined ? {} : { leak: verified.leak }),
+    };
+    return verified?.admission === undefined
+        ? accepted(state, [], value, undefined, obligations)
+        : {
+            ...admitted(verified.admission, value),
+            ...obligations,
+        };
 }
 export async function reconcileOperation(input) {
     try {
         const observation = await reconcile({
             repository: input.scope,
+            channel: input.channel,
             contractId: input.contractId,
             hooks: input.hooks,
             retryHooks: input.retryHooks,
+            ...(input.retainTerminalWorktree === undefined ? {} : { retainTerminalWorktree: input.retainTerminalWorktree }),
+            ...(input.place === undefined ? {} : { place: input.place }),
         });
         return { state: observation.state, report: observation.result };
     }
@@ -361,10 +668,19 @@ export async function reconcileOperation(input) {
         return { state: null, report: reconcileObservationFailure(error) };
     }
 }
+export async function worldContractStates(input) {
+    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
+    return [...observation.contracts.values()].flatMap((value) => value.state === null ? [] : [value.state]);
+}
 export async function reconcileAllOperation(input) {
     const git = input.scope;
-    const observation = observeGit(git);
-    const contracts = (await reconcileBatch(git, observation.contracts.keys(), input.hooks, input.retryHooks)).map((item) => ({
+    const observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
+    const contracts = (await reconcileBatch(git, input.channel, observation.contracts.keys(), {
+        hooks: input.hooks,
+        retryHooks: input.retryHooks,
+        retainTerminalWorktree: input.retainTerminalWorktree ?? false,
+        ...(input.places === undefined ? {} : { places: input.places }),
+    })).map((item) => ({
         contractId: item.contract,
         state: item.state,
         report: item.result,