@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/protocol/operations.js

@@ -1,4 +1,4 @@
-import { materializeIntegrationSnapshot, planIntegration, prepareReviewIntegration, readDeliveryDiff, } from "../git/integration.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";
@@ -6,20 +6,22 @@ import { NoGitWorldError, repositoryAt } from "../git/repository.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 { admitIntent, verifyDelivery, } from "./intent.js";
-import { admitPlacement } from "./placement.js";
-import { auditReport, readAuditAt } 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, readContractObservationAt, } from "./read/status.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { appointmentFor, readManagedWorktreeAppointment, readPlaceRegister, } from "../workspace-place.js";
 export { bindOperation } from "./bind.js";
+export { reconcileObservationFailure } from "../git/reconcile.js";
 import { accepted, admitted, complete, } from "./outcome.js";
 const REVIEWED = gate("reviewed");
 function timestamp() { return new Date().toISOString(); }
@@ -40,6 +42,19 @@ function stepStop(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;
@@ -53,15 +68,17 @@ function placementStop(result) {
     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 contractObservationOperation(input) {
-    return readContractObservationAt(input.scope, input.channel, input.contractId);
+export async function contractObservationOperation(input) {
+    return await readContractObservationAt(input.scope, input.channel, input.contractId);
 }
 export async function documentsOperationAt(scope, channel) {
     return withGitReadObservation(scope, channel, readDocuments);
@@ -76,7 +93,26 @@ 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 readDeliveryDiff(input.scope, input.integrationPredecessor, input.integrationSnapshot); }
+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;
@@ -89,7 +125,7 @@ export async function amendOperation(input) {
             ? undefined
             : { source, ...input.deriveAmendment(source) };
         if (amendment !== undefined) {
-            observation = await extendContractsForAdmissionAt(input.channel, observation, [...new Set([...(state?.terms.after ?? []), ...amendment.terms.after])]);
+            observation = await extendPrerequisiteClosureAt(input.channel, observation, [...new Set([...(state?.terms.after ?? []), ...amendment.terms.after])]);
         }
         const preparation = amendment === undefined
             ? undefined
@@ -129,32 +165,41 @@ export async function amendOperation(input) {
     }
     return { kind: "retry", reason: { kind: "exhausted" } };
 }
-export function prepareDelivery(repository, stage, input) {
+export async function prepareDelivery(repository, stage, input) {
     const { contractId, coordinates } = stage;
     if (coordinates.workspace === "here" && coordinates.target !== undefined) {
-        const branch = currentBranch(repository);
+        const branch = await currentBranch(repository);
         if (branch !== coordinates.target) {
             return { kind: "refused", refusal: { kind: "workspace-not-on-target", contractId, target: coordinates.target, branch } };
         }
     }
-    const tender = captureTender(repository, stage);
+    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: dirtyTenderRefusal(repository, contractId, tender.data) };
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
     }
-    const tenderSnapshot = materializeTenderSnapshot(repository, 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 = planIntegration(repository, stage, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
+    const integration = await planIntegration(repository, { contractId, coordinates }, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
     if (integration.kind === "refused")
         return integration;
     const integrationSnapshot = coordinates.target === undefined
         ? tenderSnapshot
-        : materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, {
+        : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, {
             contractId,
             title: input.title,
             ...(input.message === undefined ? {} : { message: input.message }),
@@ -163,28 +208,54 @@ export function prepareDelivery(repository, stage, input) {
         kind: "prepared",
         data: {
             tenderSnapshot,
-            integration: { predecessor: integration.data.predecessor, snapshot: integrationSnapshot, changeId: integration.data.changeId },
+            integration: {
+                predecessor: integration.data.predecessor,
+                snapshot: integrationSnapshot,
+                changeId: await worktreeChangeId(repository, { contractId, coordinates }, tender.data),
+            },
             method: "squash",
             policy: { requireBranchesToBeUpToDate },
         },
     };
 }
-export function prepareReview(repository, stage) {
-    const tender = captureTender(repository, stage);
+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: dirtyTenderRefusal(repository, stage.contractId, tender.data) };
+        return { kind: "refused", refusal: await dirtyTenderRefusal(repository, stage.contractId, tender.data) };
     }
-    const workspace = dirtyTenderDelta(repository, tender.data);
-    return prepareReviewIntegration(repository, stage, tender.data, workspace);
+    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 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 }),
+        },
+    };
 }
 async function deliverAttempt(input, attempt) {
-    let decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(decisionObservation.decision, input.contractId);
-    if (state !== null) {
-        decisionObservation = await extendContractsForAdmissionAt(input.channel, decisionObservation, state.terms.after);
-    }
     const derivation = state === null || input.deriveDocument === undefined
         ? undefined
         : input.deriveDocument(state);
@@ -200,7 +271,7 @@ async function deliverAttempt(input, attempt) {
         };
     }
     else {
-        const prepared = prepareDelivery(input.scope, {
+        const prepared = await prepareDelivery(input.scope, {
             contractId: state.id,
             coordinates: state.coordinates,
         }, {
@@ -247,27 +318,35 @@ async function completeDelivery(input, first) {
     }
     let admission = first;
     let verificationValue;
+    let verificationReuse;
     let cleanup;
     let leak;
-    const verification = await verifyDelivery({
-        channel: input.channel,
-        repository: input.scope,
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        state: first.state,
-        environment: process.env,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(derivation.verification.data === null
-            ? {}
-            : { verification: derivation.verification.data }),
-    });
-    if (verification !== null) {
-        cleanup = verification.cleanup;
-        leak = verification.leak;
-        verificationValue = verificationStop(verification.step);
-        if (!("failure" in verification.step) && 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 = await admitPlacement(input.channel, input.scope, first.state.coordinates.target, {
@@ -281,6 +360,7 @@ async function completeDelivery(input, first) {
     return admitted(admission, {
         ...first.value.delivery,
         ...(verificationValue === undefined ? {} : { verification: verificationValue }),
+        ...(verificationReuse === undefined ? {} : { verificationReuse }),
         ...(placementValue === undefined ? {} : { placement: placementValue }),
         ...(cleanup === undefined ? {} : { cleanup }),
         ...(leak === undefined ? {} : { leak }),
@@ -306,7 +386,7 @@ export async function deliverOperation(input) {
     }
     if (first === null)
         return { kind: "retry", reason: { kind: "exhausted" } };
-    return completeDelivery(input, first);
+    return await completeDelivery(input, first);
 }
 export async function abandonOperation(input) {
     return complete(await admitIntent(input.channel, input.scope, {
@@ -327,16 +407,20 @@ export async function arcOperation(input) {
         data: input.chapter,
     }, decideArc), undefined);
 }
-function reviewAttempt(input, attempt) {
-    return reviewAttemptObserved(input, attempt);
+function reviewValue(value, placement) {
+    return {
+        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...(placement === undefined ? {} : { placement }),
+    };
 }
-async function reviewAttemptObserved(input, attempt) {
+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 }
             : {
@@ -351,8 +435,10 @@ async function reviewAttemptObserved(input, attempt) {
                     ...(input.summary === undefined ? {} : { summary: input.summary }),
                 },
             };
-        if (prepared.kind === "prepared")
+        if (prepared.kind === "prepared") {
             workspace = prepared.data.workspace;
+            tender = prepared.data.tender;
+        }
     }
     const decisionInput = {
         contractId: input.contractId,
@@ -374,7 +460,10 @@ async function reviewAttemptObserved(input, attempt) {
     if (admitted.kind === "accepted")
         return {
             ...admitted,
-            value: workspace === undefined ? {} : { workspace },
+            value: {
+                ...(workspace === undefined ? {} : { workspace }),
+                ...(tender === undefined ? {} : { tender }),
+            },
         };
     return admitted;
 }
@@ -398,58 +487,167 @@ export async function reviewOperation(input) {
     if (review.kind !== "accepted")
         return review;
     if (input.verdict !== "satisfied")
-        return admitted(review, review.value);
-    const placement = await admitPlacement(input.channel, git, review.state.coordinates.target, {
+        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 stopped = placementStop(placement);
     const admission = placement.kind === "accepted" ? mergeAdmissions(review, placement) : review;
-    return admitted(admission, { ...review.value, ...(stopped === undefined ? {} : { placement: stopped }) });
+    return admitted(admission, reviewValue(review.value, stopped));
 }
-export async function auditOperation(input) {
-    const git = input.scope;
-    const initial = await readAuditAt(git, input.channel, input.contractId, REVIEWED);
-    if (initial.state === null)
-        return { kind: "refused", refusal: { kind: "contract-missing", contractId: input.contractId } };
-    const derivation = input.deriveDocument?.(initial.state);
-    if (derivation === undefined || !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({
         channel: input.channel,
-        repository: git,
+        repository: input.scope,
         contractId: input.contractId,
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         at: timestamp(),
-        state: initial.state,
+        state,
+        snapshot,
         environment: process.env,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-        verification: derivation.verification.data,
+        verification: definition,
     });
     if (verification === null) {
         throw new Error("audit verification preparation unexpectedly produced no attempt");
     }
-    const attempt = verificationStop(verification.step);
-    const report = !("failure" in verification.step) && verification.step.kind === "accepted"
-        ? auditReport(verification.step.journal, REVIEWED, initial.state, initial.report.targetObservation)
-        : 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.cleanup === undefined ? {} : { cleanup: verification.cleanup }),
-        ...(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 }),
+    };
+    const obligations = {
+        ...(verified?.cleanup === undefined ? {} : { cleanup: verified.cleanup }),
+        ...(verified?.leak === undefined ? {} : { leak: verified.leak }),
     };
-    return !("failure" in verification.step) && verification.step.kind === "accepted"
-        ? admitted(verification.step, value)
-        : accepted(initial.state, [], value);
+    return verified?.admission === undefined
+        ? accepted(state, [], value, undefined, obligations)
+        : {
+            ...admitted(verified.admission, value),
+            ...obligations,
+        };
 }
 export async function reconcileOperation(input) {
     try {
@@ -460,6 +658,7 @@ export async function reconcileOperation(input) {
             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 };
     }
@@ -469,13 +668,18 @@ 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 = await withGitReadObservation(input.scope, input.channel, (read) => observeContractWorld(read));
+    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,

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

@@ -1,23 +1,29 @@
 import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
+import type { WorktreeLeak } from "../git/scratch.js";
+import type { ReconcileResult } from "../git/reconcile.js";
 import type { AcceptedAdmission } from "./attempt.js";
+import type { VerificationCleanupFailure } from "./intent.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
-import type { ReconcileResult } from "../git/reconcile.js";
 export type AcceptedProtocolStep = AcceptedAdmission & Readonly<{
     physical?: ReconcileResult;
 }>;
+export type AcceptedObligations = Readonly<{
+    cleanup?: VerificationCleanupFailure;
+    leak?: WorktreeLeak;
+}>;
 export type IntentOutcome<Value, Refusal = never> = Readonly<{
     kind: "accepted";
     facts: readonly JournalEntry[];
     head: ContractHead;
     value: Value;
     physical?: ReconcileResult;
-}> | Readonly<{
+} & AcceptedObligations> | Readonly<{
     kind: "refused";
     refusal: Refusal;
 }> | Readonly<{
     kind: "retry";
     reason: ProtocolTerminal;
 }>;
-export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult): IntentOutcome<Value, Refusal>;
+export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult, obligations?: AcceptedObligations): IntentOutcome<Value, Refusal>;
 export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
 export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;

package/build/src/protocol/outcome.js

@@ -1,4 +1,4 @@
-export function accepted(state, facts, value, physical) {
+export function accepted(state, facts, value, physical, obligations) {
     if (state.head === null)
         throw new Error("accepted contract is missing its journal head");
     return {
@@ -7,6 +7,8 @@ export function accepted(state, facts, value, physical) {
         head: state.head,
         value,
         ...(physical === undefined ? {} : { physical }),
+        ...(obligations?.cleanup === undefined ? {} : { cleanup: obligations.cleanup }),
+        ...(obligations?.leak === undefined ? {} : { leak: obligations.leak }),
     };
 }
 export function admitted(admission, value) {