@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,198 @@
+import { type IntegrationPreparationRefusal } from "../git/integration.js";
+import { type DirtyWorkspaceRefusal, type WorkspaceDirtyDelta } from "../git/tender.js";
+import { type ReconcileResult } from "../git/reconcile.js";
+import type { WorktreeHooks } from "../git/hooks.js";
+import { NoGitWorldError, type GitRepository } from "../git/repository.js";
+import { type GitDecodeChannel, type GitTreeSelection } from "../git/read-observation.js";
+import type { WorktreeLeak } from "../git/scratch.js";
+import type { ActorId, AmendData, ArcData, AttestationData, ContractId, ContractState, ContractTerms, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
+import { type AbandonRefusal } from "../core/verbs/abandon.js";
+import { type AmendRefusal } from "../core/verbs/amend.js";
+import { type ArcRefusal } from "../core/verbs/arc.js";
+import { type DeliverRefusal } from "../core/verbs/deliver.js";
+import type { PlacementRefusal } from "../core/verbs/placement.js";
+import { type AttestationRefusal } from "../core/verbs/attestation.js";
+import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
+import { type VerificationRuntimeStop, type VerificationCleanupFailure } from "./intent.js";
+import type { TargetPlacementRefusal } from "../git/target-placement.js";
+import { type AuditReport as AuditReadReport } from "./read/audit.js";
+import { type ContractDocumentProjection } from "./read/documents.js";
+import { type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow } from "./read/status.js";
+export { bindOperation } from "./bind.js";
+import type { BindRefusal, TargetInputRefusal } from "./bind.js";
+import { type IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
+import type { ProtocolTerminal } from "./run.js";
+import type { CompanionDecorator } from "./run.js";
+export type { FactKind, TimelineEntry } from "./read/audit.js";
+export type { ContractDocumentProjection } from "./read/documents.js";
+type DeliveryPreparationRefusal = Readonly<{
+    kind: "target-missing" | "worktree-missing";
+    contractId: ContractId;
+}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal | TargetPlacementRefusal;
+type ReviewPreparationRefusal = Readonly<{
+    kind: "target-missing" | "worktree-missing";
+    contractId: ContractId;
+}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal;
+type ReviewRefusal = AttestationRefusal | ReviewPreparationRefusal;
+export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | PlacementRefusal | ReviewRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
+export type { TargetInputRefusal } from "./bind.js";
+export type IntentRetry = ProtocolTerminal;
+export type IntentOutcome<Value, Refusal = IntentRefusal> = ProtocolIntentOutcome<Value, Refusal>;
+type OperationInput = Readonly<{
+    scope: RepositoryScope;
+    contractId: ContractId;
+    actor?: ActorId;
+}>;
+type MutationOperationInput = OperationInput & Readonly<{
+    channel: GitDecodeChannel;
+}>;
+export type AuditReport = AuditReadReport & Readonly<{
+    attempt?: VerificationStop;
+    cleanup?: VerificationCleanupFailure;
+    leak?: WorktreeLeak;
+}>;
+export type DocumentDerivation = Readonly<{
+    document: DocumentKey;
+    title: string;
+    verification: VerificationDeclarationPreparation;
+}>;
+export type StepStop<R> = Readonly<{
+    refusal: R;
+    retry?: never;
+} | {
+    retry: IntentRetry;
+    refusal?: never;
+}>;
+export type VerificationStop = StepStop<AttestationRefusal> | VerificationRuntimeStop;
+export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal> | Readonly<{
+    failure: "target-moved";
+    contractId: ContractId;
+    target: string;
+    expected: SnapshotId;
+    observed: SnapshotId | null;
+}> | Readonly<{
+    failure: "target-placement-failed";
+    diagnostic: string;
+}>;
+type ScopeOperationInput = Readonly<{
+    coordinate: string;
+}>;
+export type RepositoryScope = GitRepository;
+export { NoGitWorldError };
+export declare function scopeOperation(input: ScopeOperationInput): RepositoryScope;
+export declare function currentBranchOperation(input: Readonly<{
+    scope: RepositoryScope;
+}>): string | null;
+export declare function contractsOperation(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+}>): Promise<ContractBoard>;
+export declare function contractObservationOperation(input: MutationOperationInput): Promise<ContractObservation>;
+export type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow };
+export declare function documentsOperationAt(scope: RepositoryScope, channel: GitDecodeChannel): Promise<readonly ContractDocumentProjection[]>;
+export declare function stateOperation(input: MutationOperationInput): Promise<ContractState>;
+type DeliveryIdentity = DeliverData;
+export declare function deliveryOperation(input: MutationOperationInput): Promise<DeliveryIdentity | null>;
+type DeliveryDiffOperationInput = Readonly<{
+    scope: RepositoryScope;
+    integrationPredecessor: SnapshotId;
+    integrationSnapshot: SnapshotId;
+}>;
+export declare function deliveryDiffOperation(input: DeliveryDiffOperationInput): Promise<string | null>;
+type AmendOperationInput = MutationOperationInput & Readonly<{
+    source?: ContractTerms;
+    deriveAmendment?: (source: ContractTerms) => Readonly<{
+        terms: AmendData;
+        verification: VerificationDeclarationPreparation;
+    }>;
+}>;
+type Amendment = Readonly<{
+    source: ContractTerms;
+}> & ReturnType<NonNullable<AmendOperationInput["deriveAmendment"]>>;
+export declare function amendOperation(input: AmendOperationInput): Promise<IntentOutcome<Amendment, AmendRefusal | VerificationDeclarationRefusal>>;
+export type DeliverValue = DeliveryIdentity & Readonly<{
+    verification?: VerificationStop;
+    placement?: PlacementStop;
+    cleanup?: VerificationCleanupFailure;
+    leak?: WorktreeLeak;
+}>;
+type DeliverOperationInput = MutationOperationInput & Readonly<{
+    deriveDocument?: (state: ContractState) => DocumentDerivation;
+    message?: string;
+    requireBranchesToBeUpToDate: boolean;
+    includeDirty: boolean;
+    signal?: AbortSignal;
+}>;
+export declare function prepareDelivery(repository: GitRepository, stage: Readonly<{
+    contractId: ContractId;
+    coordinates: ContractState["coordinates"];
+}>, input: Readonly<{
+    title: string;
+    message?: string;
+    requireBranchesToBeUpToDate?: boolean;
+    includeDirty?: boolean;
+}>): {
+    kind: "prepared";
+    data: DeliverData;
+} | {
+    kind: "refused";
+    refusal: DeliveryPreparationRefusal;
+};
+export declare function prepareReview(repository: GitRepository, stage: Readonly<{
+    contractId: ContractId;
+    coordinates: ContractState["coordinates"];
+}>): {
+    kind: "prepared";
+    data: Readonly<{
+        changeId: DeliverData["integration"]["changeId"];
+        workspace?: WorkspaceDirtyDelta;
+    }>;
+} | {
+    kind: "refused";
+    refusal: ReviewPreparationRefusal;
+};
+export declare function deliverOperation(input: DeliverOperationInput): Promise<IntentOutcome<DeliverValue>>;
+export declare function abandonOperation(input: MutationOperationInput & Readonly<{
+    note?: string;
+    decorateOffer?: CompanionDecorator;
+    observationSelection?: GitTreeSelection;
+}>): Promise<IntentOutcome<void, AbandonRefusal>>;
+export declare function arcOperation(input: MutationOperationInput & Readonly<{
+    chapter: Omit<ArcData, "seq">;
+}>): Promise<IntentOutcome<void, ArcRefusal>>;
+type ReviewOperationInput = MutationOperationInput & Readonly<{
+    verdict: AttestationData["verdict"];
+    summary?: string;
+}>;
+export type ReviewValue = Readonly<{
+    placement?: PlacementStop;
+    workspace?: WorkspaceDirtyDelta;
+}>;
+export declare function reviewOperation(input: ReviewOperationInput): Promise<IntentOutcome<ReviewValue, ReviewRefusal>>;
+export declare function auditOperation(input: MutationOperationInput & Readonly<{
+    deriveDocument?: (state: ContractState) => DocumentDerivation;
+    signal?: AbortSignal;
+}>): Promise<IntentOutcome<AuditReport>>;
+export type ReconcileReport = ReconcileResult;
+export type ReconcileObservation = Readonly<{
+    state: ContractState | null;
+    report: ReconcileReport;
+}>;
+type ReconcileOptions = Readonly<{
+    hooks: WorktreeHooks;
+    retryHooks: boolean;
+    retainTerminalWorktree?: boolean;
+}>;
+export declare function reconcileOperation(input: MutationOperationInput & ReconcileOptions): Promise<ReconcileObservation>;
+type RepoReconcileItem = Readonly<{
+    contractId: ContractId;
+    state: ContractState | null;
+    report: ReconcileReport;
+}>;
+export type RepoReconcileReport = Readonly<{
+    contracts: readonly RepoReconcileItem[];
+}>;
+export declare function reconcileAllOperation(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+}> & ReconcileOptions): Promise<RepoReconcileReport>;

package/build/src/protocol/operations.js

@@ -0,0 +1,485 @@
+import { materializeIntegrationSnapshot, planIntegration, prepareReviewIntegration, readDeliveryDiff, } 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 { 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 { 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 { readDocuments } from "./read/documents.js";
+import { readContractBoard, readContractObservationAt, } from "./read/status.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+export { bindOperation } from "./bind.js";
+import { accepted, admitted, complete, } from "./outcome.js";
+const REVIEWED = gate("reviewed");
+function timestamp() { return new Date().toISOString(); }
+function mergeAdmissions(current, next) {
+    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 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 contractsOperation(input) {
+    return withGitReadObservation(input.scope, input.channel, readContractBoard);
+}
+export function contractObservationOperation(input) {
+    return readContractObservationAt(input.scope, input.channel, input.contractId);
+}
+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 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 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 extendContractsForAdmissionAt(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 function prepareDelivery(repository, stage, input) {
+    const { contractId, coordinates } = stage;
+    if (coordinates.workspace === "here" && coordinates.target !== undefined) {
+        const branch = 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);
+    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) };
+    }
+    const tenderSnapshot = 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);
+    if (integration.kind === "refused")
+        return integration;
+    const integrationSnapshot = coordinates.target === undefined
+        ? tenderSnapshot
+        : materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, {
+            contractId,
+            title: input.title,
+            ...(input.message === undefined ? {} : { message: input.message }),
+        });
+    return {
+        kind: "prepared",
+        data: {
+            tenderSnapshot,
+            integration: { predecessor: integration.data.predecessor, snapshot: integrationSnapshot, changeId: integration.data.changeId },
+            method: "squash",
+            policy: { requireBranchesToBeUpToDate },
+        },
+    };
+}
+export function prepareReview(repository, stage) {
+    const tender = captureTender(repository, stage);
+    if (tender.kind === "refused")
+        return tender;
+    if (tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: dirtyTenderRefusal(repository, stage.contractId, tender.data) };
+    }
+    const workspace = dirtyTenderDelta(repository, tender.data);
+    return prepareReviewIntegration(repository, stage, tender.data, workspace);
+}
+async function deliverAttempt(input, attempt) {
+    let 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);
+    let preparation;
+    if (state === null || derivation === undefined) {
+        preparation = { kind: "unavailable" };
+    }
+    else if (derivation.verification.kind === "refused") {
+        preparation = {
+            kind: "refused",
+            document: derivation.document,
+            refusal: derivation.verification.refusal,
+        };
+    }
+    else {
+        const prepared = prepareDelivery(input.scope, {
+            contractId: state.id,
+            coordinates: state.coordinates,
+        }, {
+            title: derivation.title,
+            ...(input.message === undefined ? {} : { message: input.message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+        });
+        preparation = prepared.kind === "refused"
+            ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
+            : { kind: "prepared", document: derivation.document, data: prepared.data };
+    }
+    const decisionInput = {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+        preparation,
+    };
+    const decision = decideDeliver({ input: decisionInput, attempt, observation: decisionObservation.decision });
+    if (decision.kind === "refused")
+        return { kind: "refused", refusal: decision.refusal };
+    if (preparation.kind !== "prepared") {
+        throw new Error("offered delivery is missing its mechanical preparation");
+    }
+    const admitted = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
+    if (admitted.kind === "accepted") {
+        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) {
+    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 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 placement = await admitPlacement(input.channel, input.scope, first.state.coordinates.target, {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+    });
+    const placementValue = placementStop(placement);
+    if (placement.kind === "accepted")
+        admission = mergeAdmissions(admission, placement);
+    return admitted(admission, {
+        ...first.value.delivery,
+        ...(verificationValue === undefined ? {} : { verification: verificationValue }),
+        ...(placementValue === undefined ? {} : { placement: placementValue }),
+        ...(cleanup === undefined ? {} : { cleanup }),
+        ...(leak === undefined ? {} : { leak }),
+    });
+}
+export async function deliverOperation(input) {
+    const attempts = mintAttempts({ entryCount: 2 });
+    let first = null;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const result = await deliverAttempt(input, attempts[index]);
+        if (result.kind === "accepted") {
+            first = result;
+            break;
+        }
+        if (result.kind === "refused")
+            return result;
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+        if (result.kind === "redecide")
+            continue;
+    }
+    if (first === null)
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    return completeDelivery(input, first);
+}
+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 }),
+        ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
+    }), undefined);
+}
+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) {
+    return reviewAttemptObserved(input, attempt);
+}
+async function reviewAttemptObserved(input, attempt) {
+    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(decisionObservation.decision, input.contractId);
+    let preparation;
+    let workspace;
+    if (state !== null) {
+        const prepared = prepareReview(input.scope, { contractId: state.id, coordinates: state.coordinates });
+        preparation = prepared.kind === "refused"
+            ? { kind: "refused", refusal: prepared.refusal }
+            : {
+                kind: "prepared",
+                data: {
+                    gate: REVIEWED,
+                    subject: dependencyKeySet([
+                        { kind: "document", value: state.terms.document.key },
+                        { kind: "change", value: prepared.data.changeId },
+                    ]),
+                    verdict: input.verdict,
+                    ...(input.summary === undefined ? {} : { summary: input.summary }),
+                },
+            };
+        if (prepared.kind === "prepared")
+            workspace = prepared.data.workspace;
+    }
+    const decisionInput = {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+        ...(preparation === undefined ? {} : { preparation }),
+    };
+    const decision = decideAttestation({ input: decisionInput, attempt, observation: decisionObservation.decision });
+    if (decision.kind === "refused")
+        return { kind: "refused", refusal: decision.refusal };
+    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: workspace === undefined ? {} : { workspace },
+        };
+    return admitted;
+}
+export async function reviewOperation(input) {
+    const git = input.scope;
+    const attempts = mintAttempts({ entryCount: 1 });
+    let review = null;
+    for (let index = 0; index < attempts.length; index += 1) {
+        const result = await reviewAttempt(input, attempts[index]);
+        if (result.kind === "accepted" || result.kind === "refused") {
+            review = result;
+            break;
+        }
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    if (review === null)
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    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, {
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+    });
+    const stopped = placementStop(placement);
+    const admission = placement.kind === "accepted" ? mergeAdmissions(review, placement) : review;
+    return admitted(admission, { ...review.value, ...(stopped === undefined ? {} : { placement: 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);
+    }
+    const verification = await verifyDelivery({
+        channel: input.channel,
+        repository: git,
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        at: timestamp(),
+        state: initial.state,
+        environment: process.env,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        verification: derivation.verification.data,
+    });
+    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;
+    const value = {
+        ...report,
+        ...(attempt === undefined ? {} : { attempt }),
+        ...(verification.cleanup === undefined ? {} : { cleanup: verification.cleanup }),
+        ...(verification.leak === undefined ? {} : { leak: verification.leak }),
+    };
+    return !("failure" in verification.step) && verification.step.kind === "accepted"
+        ? admitted(verification.step, value)
+        : accepted(initial.state, [], value);
+}
+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 }),
+        });
+        return { state: observation.state, report: observation.result };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { state: null, report: reconcileObservationFailure(error) };
+    }
+}
+export async function reconcileAllOperation(input) {
+    const git = input.scope;
+    const observation = await withGitReadObservation(input.scope, input.channel, (read) => observeContractWorld(read));
+    const contracts = (await reconcileBatch(git, input.channel, observation.contracts.keys(), {
+        hooks: input.hooks,
+        retryHooks: input.retryHooks,
+        retainTerminalWorktree: input.retainTerminalWorktree ?? false,
+    })).map((item) => ({
+        contractId: item.contract,
+        state: item.state,
+        report: item.result,
+    }));
+    return { contracts };
+}