@astrosheep/keiyaku 4.0.4 → 4.0.6

package/build/src/protocol/deliver.js

@@ -0,0 +1,261 @@
+import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, workspaceMergeStatePresent, worktreeChangeId, } from "../git/integration.js";
+import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
+import { worktreePath } from "../git/workspace.js";
+import { currentBranch, observeContractsForAdmissionAt } from "../git/observe.js";
+import { contractState } from "../core/facts/observation.js";
+import { decideDeliver } from "../core/verbs/deliver.js";
+import { admitDecidedOffer, mintAttempts } from "./attempt.js";
+import { admitted } from "./outcome.js";
+import { completeCandidate } from "./completion.js";
+import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
+import { timestamp } from "./operations.js";
+const DELIVER_CONFLICT_RECOVERY = Object.freeze({
+    materialize: "deliver --materialize-conflict",
+    continue: "deliver",
+});
+export async function prepareDelivery(repository, stage, input) {
+    const { contractId, coordinates } = stage;
+    if (coordinates.workspace === "here" && coordinates.target !== undefined) {
+        const branch = await currentBranch(repository, stage.workspacePath);
+        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 }),
+        ...(stage.workspacePath === undefined ? {} : { workspacePath: stage.workspacePath }),
+    });
+    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 commit = await prepareDeliveryCommitMetadata(repository, {
+        contractId,
+        title: input.title,
+        document: input.document,
+        at: tender.data.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.message === undefined ? {} : { message: input.message }),
+    });
+    const tenderSnapshot = await materializeTenderSnapshot(repository, tender.data, commit);
+    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, commit);
+    return {
+        kind: "prepared",
+        data: {
+            tenderSnapshot,
+            integration: {
+                predecessor: integration.data.predecessor,
+                snapshot: integrationSnapshot,
+                changeId: await worktreeChangeId(repository, { contractId, coordinates }, tender.data),
+            },
+            method: "squash",
+            policy: { requireBranchesToBeUpToDate },
+        },
+    };
+}
+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 ? undefined : input.deriveDocument(state);
+    let preparation;
+    let workspacePath;
+    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 {
+        workspacePath = state.terminal === null && state.coordinates.workspace === "here"
+            ? await input.resolveHereWorkspace?.(state.id)
+            : undefined;
+        const prepared = await prepareDelivery(input.scope, {
+            contractId: state.id,
+            coordinates: state.coordinates,
+            ...(workspacePath === undefined ? {} : { workspacePath }),
+        }, {
+            title: derivation.title,
+            document: derivation.bytes,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(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,
+                ...(workspacePath === undefined ? {} : { workspacePath }),
+            };
+    }
+    const decision = decideDeliver({
+        input: {
+            contractId: input.contractId,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            at: timestamp(),
+            preparation,
+        },
+        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 admission = await admitDecidedOffer({
+        channel: input.channel,
+        repository: input.scope,
+        decisionObservation,
+        attempt,
+        offer: decision.offer,
+        primaryContract: input.contractId,
+    });
+    if (admission.kind === "accepted") {
+        if (derivation === undefined)
+            throw new Error("accepted delivery is missing its document derivation");
+        return {
+            ...admission,
+            value: {
+                delivery: preparation.data,
+                derivation,
+                ...(workspacePath === undefined ? {} : { workspacePath }),
+            },
+        };
+    }
+    return admission;
+}
+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");
+    }
+    const completed = await completeCandidate({
+        channel: input.channel,
+        repository: input.scope,
+        contractId: input.contractId,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(first.value.workspacePath === undefined ? {} : { hereWorkspacePath: first.value.workspacePath }),
+        ...(first.state.coordinates.target === undefined ? {} : { target: first.state.coordinates.target }),
+        verification: derivation.verification,
+        initial: first,
+        verifyInitial: true,
+    });
+    return admitted(completed.admission, {
+        ...first.value.delivery,
+        ...completed.evidence,
+    });
+}
+function isIntegrationConflict(refusal) {
+    return refusal.kind === "integration-failed" && refusal.reason === "conflict";
+}
+function conflictDeliverRefusal(refusal) {
+    if (refusal.conflictPaths === undefined)
+        throw new Error("conflicted integration is missing conflict paths");
+    return {
+        kind: "integration-failed",
+        contractId: refusal.contractId,
+        reason: "conflict",
+        targetHead: refusal.targetHead,
+        conflictPaths: refusal.conflictPaths,
+        recovery: DELIVER_CONFLICT_RECOVERY,
+    };
+}
+async function appointedDeliverWorkspace(input) {
+    const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null)
+        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
+    if (state.coordinates.workspace === "here") {
+        const path = await input.resolveHereWorkspace?.(state.id);
+        if (path === undefined) {
+            return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
+        }
+        return { workspace: { kind: "here", path }, coordinates: state.coordinates };
+    }
+    const appointment = appointmentFor(await readPlaceRegister(input.scope), input.contractId);
+    if (appointment === undefined) {
+        return { kind: "refused", refusal: { kind: "worktree-missing", contractId: input.contractId } };
+    }
+    return {
+        workspace: { kind: "worktree", path: worktreePath(input.scope, appointment.place) },
+        coordinates: state.coordinates,
+    };
+}
+async function materializeDeliverConflict(input, refusal) {
+    if (refusal.conflictPaths === undefined)
+        throw new Error("conflicted integration is missing conflict paths");
+    const appointed = await appointedDeliverWorkspace(input);
+    if ("kind" in appointed)
+        return appointed;
+    const { workspace, coordinates } = appointed;
+    if (await workspaceMergeStatePresent(input.scope, workspace.path)) {
+        return {
+            kind: "refused",
+            refusal: { kind: "merge-state-present", contractId: input.contractId, workspace },
+        };
+    }
+    const tender = await captureTender(input.scope, {
+        contractId: input.contractId,
+        coordinates,
+        workspacePath: workspace.path,
+    });
+    if (tender.kind === "refused")
+        return tender;
+    if (tender.data.dirty || tender.data.changes.submodules.length > 0) {
+        return { kind: "refused", refusal: await dirtyTenderRefusal(input.scope, input.contractId, tender.data) };
+    }
+    await materializeJudgedConflict(input.scope, workspace.path, refusal.targetHead);
+    return {
+        kind: "integration-conflict-materialized",
+        targetHead: refusal.targetHead,
+        conflictPaths: refusal.conflictPaths,
+        workspace,
+    };
+}
+async function finishDeliverRefusal(input, refusal) {
+    if (!isIntegrationConflict(refusal))
+        return { kind: "refused", refusal };
+    if (input.materializeConflict !== true)
+        return { kind: "refused", refusal: conflictDeliverRefusal(refusal) };
+    return await materializeDeliverConflict(input, refusal);
+}
+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 await finishDeliverRefusal(input, result.refusal);
+        if (result.kind === "publication-failed")
+            return { kind: "retry", reason: result };
+        if (result.kind === "collision" && index + 1 === attempts.length)
+            return { kind: "retry", reason: result };
+    }
+    if (first === null)
+        return { kind: "retry", reason: { kind: "exhausted" } };
+    return await completeDelivery(input, first);
+}

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

@@ -1,6 +1,6 @@
 import type { GitDecisionObservation } from "../git/observe.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
-import type { GitRepository } from "../git/repository.js";
+import type { GitRepository } from "../git/process.js";
 import type { GitRefAssertion } from "../git/repository.js";
 import { type WorktreeLeak } from "../git/scratch.js";
 import type { HookFailure } from "../git/hooks.js";
@@ -81,6 +81,7 @@ export type VerificationResult = Readonly<{
 export type CurrentVerifiedAttestation = Readonly<{
     entry: EntryUlid;
     verdict: "satisfied" | "unsatisfied";
+    summary?: string;
 }>;
 /** Read the latest current verified attestation through the generic currentness judge. */
 export declare function currentVerifiedAttestation(state: ContractState): CurrentVerifiedAttestation | undefined;

package/build/src/protocol/intent.js

@@ -47,11 +47,17 @@ function verificationInput(outcome, input, subject) {
 /** Read the latest current verified attestation through the generic currentness judge. */
 export function currentVerifiedAttestation(state) {
     const current = latestCurrentAttestations(state, new Set([VERIFIED])).get(VERIFIED);
-    return current === undefined ? undefined : { entry: current.entry, verdict: current.data.verdict };
+    return current === undefined
+        ? undefined
+        : {
+            entry: current.entry,
+            verdict: current.data.verdict,
+            ...(current.data.summary === undefined ? {} : { summary: current.data.summary }),
+        };
 }
 /** Run Verification against an explicit or admitted integration snapshot. */
 export async function verifyDelivery(input) {
-    const snapshot = input.snapshot ?? input.state.delivery?.data.integration.snapshot;
+    const snapshot = input.snapshot ?? input.state.currentIntegration?.snapshot;
     if (snapshot === undefined || input.verification === undefined)
         return null;
     const subject = dependencyKeySet([

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

@@ -1,252 +1,143 @@
-import { type DeliveryDiffScope, 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 DirtyWorkspaceRefusal } from "../git/tender.js";
+import type { GitRepository } from "../git/process.js";
+import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
-import type { ActorId, AmendData, ArcData, AttestationData, ChangeId, 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 { 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 { AttestationRefusal } from "../core/verbs/attestation.js";
+import type { ContractId, ContractState, DeliverData, DocumentKey, SnapshotId } from "../core/facts/types.js";
+import type { BindRefusal, TargetInputRefusal } from "./bind.js";
+import type { IntegrationPreparationRefusal } from "../git/integration.js";
+import type { TargetPlacementRefusal } from "../git/target-placement.js";
+import type { VerificationCleanupFailure, VerificationRuntimeStop, VerificationResult } from "./intent.js";
 import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
-import { type CurrentVerifiedAttestation, type VerificationRuntimeStop, type VerificationCleanupFailure } from "./intent.js";
-import { type AuditTargetAnswer, type TargetPlacementRefusal } from "../git/target-placement.js";
+import type { PlacementProtocolResult } from "./placement.js";
+import type { AcceptedAdmission, DecidedOfferResult } from "./attempt.js";
+import type { AcceptedProtocolStep, IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
+import type { ProtocolResult, ProtocolTerminal } from "./run.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";
-import { type ManagedWorktreeAppointment } from "../workspace-place.js";
-export { bindOperation } from "./bind.js";
-export { reconcileObservationFailure } from "../git/reconcile.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 } from "../core/facts/types.js";
-export type { ContractDocumentProjection } from "./read/documents.js";
+import { type ContractBoard, type ContractObservation } from "./read/status.js";
+export type MergeStatePresentRefusal = Readonly<{
+    kind: "merge-state-present";
+    contractId: ContractId;
+    workspace: Readonly<{
+        kind: "here" | "worktree";
+        path: string;
+    }>;
+}>;
+export type DeliverConflictRefusal = Readonly<{
+    kind: "integration-failed";
+    contractId: ContractId;
+    reason: "conflict";
+    targetHead: SnapshotId;
+    conflictPaths: readonly string[];
+    recovery: Readonly<{
+        materialize: "deliver --materialize-conflict";
+        continue: "deliver";
+    }>;
+}>;
 export type DeliveryPreparationRefusal = Readonly<{
     kind: "target-missing" | "worktree-missing";
     contractId: ContractId;
-}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal | TargetPlacementRefusal;
-type ReviewPreparationRefusal = Readonly<{
-    kind: "worktree-missing";
-    contractId: ContractId;
-}> | DirtyWorkspaceRefusal;
-type ReviewRefusal = AttestationRefusal | ReviewPreparationRefusal;
-export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | PlacementRefusal | ReviewRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
-export type { TargetInputRefusal } from "./bind.js";
+}> | DirtyWorkspaceRefusal | IntegrationPreparationRefusal | MergeStatePresentRefusal | TargetPlacementRefusal;
+export type IntentRefusal = AbandonRefusal | AmendRefusal | ArcRefusal | BindRefusal | DeliverRefusal | DeliveryPreparationRefusal | DeliverConflictRefusal | PlacementRefusal | AttestationRefusal | TargetInputRefusal | VerificationDeclarationRefusal;
 export type IntentRetry = ProtocolTerminal;
 export type IntentOutcome<Value, Refusal = IntentRefusal> = ProtocolIntentOutcome<Value, Refusal>;
 type OperationInput = Readonly<{
     scope: RepositoryScope;
     contractId: ContractId;
-    actor?: ActorId;
+    actor?: import("../core/facts/types.js").ActorId;
 }>;
-type MutationOperationInput = OperationInput & Readonly<{
+export type HereWorkspaceResolver = (contractId: ContractId) => Promise<string | undefined>;
+export type MutationOperationInput = OperationInput & Readonly<{
     channel: GitDecodeChannel;
+    resolveHereWorkspace?: HereWorkspaceResolver;
 }>;
-export type AuditWorkspace = Readonly<{
-    kind: "worktree" | "here";
-    path: string;
-}>;
-export type DiffScope = DeliveryDiffScope;
-export type AuditReport = Readonly<{
-    candidate: Readonly<{
-        kind: "blocked";
-        refusal: DeliveryPreparationRefusal;
-    }> | Readonly<{
-        kind: "ready";
-        workspace: AuditWorkspace;
-        identity: DeliveryIdentity;
-        scope: DiffScope;
-        diff?: string;
-    }>;
-    verification: Readonly<{
-        kind: "not-run";
-    }> | Readonly<{
-        kind: "satisfied";
-        passed: number;
-        total: number;
-        summary?: string;
-    }> | Readonly<{
-        kind: "unsatisfied";
-        passed: number;
-        total: number;
-        summary?: string;
-    }> | Readonly<{
-        kind: "stopped";
-        stop: VerificationStop;
-    }>;
-    target: Readonly<{
-        kind: "not-observed";
-    }> | AuditTargetAnswer;
-    delivery?: Readonly<{
-        changeId: ChangeId;
-        relation: "identical" | "differs";
-    }>;
-}>;
-export type VerificationReuse = CurrentVerifiedAttestation;
 export type DocumentDerivation = Readonly<{
     document: DocumentKey;
     bytes: string;
     title: string;
     verification: VerificationDeclarationPreparation;
 }>;
-export type StepStop<R> = Readonly<{
+type StepStop<R> = Readonly<{
     refusal: R;
     retry?: never;
 } | {
     retry: IntentRetry;
     refusal?: never;
 }>;
-export type VerificationStop = StepStop<AttestationRefusal> | VerificationRuntimeStop;
-export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal | IntegrationPreparationRefusal> | Readonly<{
+export type VerificationStop = StepStop<AttestationRefusal | VerificationDeclarationRefusal> | VerificationRuntimeStop;
+export type PlacementStop = StepStop<PlacementRefusal | TargetPlacementRefusal | IntegrationPreparationRefusal | Readonly<{
+    kind: "target-missing";
+    contractId: ContractId;
+}>> | Readonly<{
     failure: "target-moved";
     contractId: ContractId;
     target: string;
     expected: SnapshotId;
     observed: SnapshotId | null;
+}> | Readonly<{
+    failure: "target-moved";
+    contractId: ContractId;
+    target: string;
+    integratedAt: SnapshotId;
+    observed: SnapshotId | null;
+    attempts: number;
 }> | Readonly<{
     failure: "target-placement-failed";
     diagnostic: string;
 }>;
-type ScopeOperationInput = Readonly<{
-    coordinate: string;
+export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission & Readonly<{
+    value: Value;
+}>) | Readonly<{
+    kind: "refused";
+    refusal: Refusal;
+}> | Readonly<{
+    kind: "redecide";
+}> | Readonly<{
+    kind: "collision";
+}> | Extract<DecidedOfferResult, {
+    kind: "publication-failed";
+}>;
+export declare function timestamp(): string;
+export declare function mergeAdmissions(current: AcceptedProtocolStep, next: AcceptedProtocolStep): AcceptedProtocolStep;
+export declare function stepStop<Refusal>(result: ProtocolResult<Refusal>): StepStop<Refusal> | undefined;
+export declare function unpackVerificationOutcome(verification: VerificationResult): Readonly<{
+    cleanup?: VerificationCleanupFailure;
+    leak?: WorktreeLeak;
+    stop?: VerificationStop;
+    admission?: AcceptedProtocolStep;
+    counts?: NonNullable<VerificationResult["counts"]>;
 }>;
+export declare function placementStop(result: PlacementProtocolResult<IntegrationPreparationRefusal>): PlacementStop | undefined;
 export type RepositoryScope = GitRepository;
-export { NoGitWorldError };
-export declare function scopeOperation(input: ScopeOperationInput): Promise<RepositoryScope>;
+export declare function scopeOperation(input: Readonly<{
+    coordinate: string;
+    gitPath?: string;
+}>): Promise<RepositoryScope>;
 export declare function currentBranchOperation(input: Readonly<{
     scope: RepositoryScope;
 }>): Promise<string | null>;
 export declare function contractsOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
+    hereWorkspace?: import("./read/status.js").HereWorkspaceObservationResolver;
 }>): Promise<ContractBoard>;
-export declare function contractObservationOperation(input: MutationOperationInput): Promise<ContractObservation>;
-export type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow };
+export declare function contractObservationOperation(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    contractId: ContractId;
+    hereWorkspace?: import("./read/status.js").HereWorkspaceObservationResolver;
+}>): Promise<ContractObservation>;
 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<{
+export declare function deliveryOperation(input: MutationOperationInput): Promise<DeliverData | null>;
+export declare function deliveryDiffOperation(input: 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;
-    verificationReuse?: VerificationReuse;
-    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"];
-    appointment?: Extract<ManagedWorktreeAppointment, {
-        kind: "appointed";
-    }>;
-}>, input: Readonly<{
-    title: string;
-    document: string;
-    actor?: ActorId;
-    message?: string;
-    requireBranchesToBeUpToDate?: boolean;
-    includeDirty?: boolean;
-}>): Promise<{
-    kind: "prepared";
-    data: DeliverData;
-} | {
-    kind: "refused";
-    refusal: DeliveryPreparationRefusal;
-}>;
-export declare function prepareReview(repository: GitRepository, stage: Readonly<{
-    contractId: ContractId;
-    coordinates: ContractState["coordinates"];
-}>): Promise<{
-    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>>;
-type AuditOperationInput = MutationOperationInput & Readonly<{
-    deriveDocument?: (state: ContractState) => DocumentDerivation;
-    requireBranchesToBeUpToDate?: boolean;
-    includeDirty?: boolean;
-    showDiff?: boolean;
-    signal?: AbortSignal;
-}>;
-export declare function auditOperation(input: AuditOperationInput): 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;
-    place?: string;
-    places?: ReadonlyMap<ContractId, string>;
-}>;
-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 worldContractStates(input: Readonly<{
-    scope: RepositoryScope;
-    channel: GitDecodeChannel;
-}>): Promise<readonly ContractState[]>;
-export declare function reconcileAllOperation(input: Readonly<{
-    scope: RepositoryScope;
-    channel: GitDecodeChannel;
-}> & ReconcileOptions): Promise<RepoReconcileReport>;
+}>): Promise<string | null>;
+export {};