@astrosheep/keiyaku 4.0.4 → 4.0.6

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

@@ -2,8 +2,8 @@ import type { ActorId, ContractId, SnapshotId } from "../core/facts/types.js";
 import { type PlacementRefusal } from "../core/verbs/placement.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type ReconcileResult } from "../git/reconcile.js";
-import { type GitRepository } from "../git/repository.js";
-import { type TargetPlacementObservationInput, type TargetPlacementRefusal } from "../git/target-placement.js";
+import { type GitRepository } from "../git/process.js";
+import { type TargetPlacementRefusal } from "../git/target-placement.js";
 import { type AcceptedAdmission } from "./attempt.js";
 import { type ProtocolResult } from "./run.js";
 export type PlacementExecutionFailure = Readonly<{
@@ -25,17 +25,16 @@ type PlacementProtocolInput = Readonly<{
     actor?: ActorId;
     at: string;
 }>;
-export type ProspectiveTargetPreview = Readonly<{
-    kind: "ready";
-}> | Readonly<{
-    kind: "refused";
-    refusal: TargetPlacementRefusal;
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
+type PlacementAdmissionInput<ExtraRefusal> = Readonly<{
+    channel: GitDecodeChannel;
+    repository: GitRepository;
+    target: string | undefined;
+    placement: PlacementProtocolInput;
+    hereWorkspacePath?: string;
+    onDeliveryMissing?: () => Promise<PlacementProtocolResult<ExtraRefusal> | undefined>;
 }>;
-/** Observe prospective target followability without fencing or placing. */
-export declare function observeProspectiveTargetPlacement(repository: GitRepository, input: TargetPlacementObservationInput): Promise<ProspectiveTargetPreview>;
+/** Hold the existing target-placement fence for one owner callback. */
+export declare function runUnderTargetPlacementFence<T>(repository: GitRepository, target: string, run: () => Promise<T>, onReleaseFailure?: (result: T, error: unknown) => T | PlacementExecutionFailure): Promise<T | PlacementExecutionFailure>;
 /** Run the sole placement adjudicator inside the target's physical fence. */
-export declare function admitPlacement<ExtraRefusal = never>(channel: GitDecodeChannel, repository: GitRepository, target: string | undefined, input: PlacementProtocolInput, onDeliveryMissing?: () => Promise<PlacementProtocolResult<ExtraRefusal> | undefined>): Promise<PlacementProtocolResult<ExtraRefusal>>;
+export declare function admitPlacement<ExtraRefusal = never>(admission: PlacementAdmissionInput<ExtraRefusal>): Promise<PlacementProtocolResult<ExtraRefusal>>;
 export {};

package/build/src/protocol/placement.js

@@ -4,8 +4,8 @@ import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeGitForAdmissionAt } from "../git/observe.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
-import { GitPlumbingError } from "../git/repository.js";
-import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, observeTargetPlacement, } from "../git/target-placement.js";
+import { GitPlumbingError } from "../git/process.js";
+import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { prepareProtocolAttempt, runProtocol, } from "./run.js";
 function placementFailure(error) {
@@ -20,19 +20,7 @@ function expectedOperationalDiagnostic(error) {
 function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
-/** Observe prospective target followability without fencing or placing. */
-export async function observeProspectiveTargetPlacement(repository, input) {
-    try {
-        const observed = await observeTargetPlacement(repository, input);
-        return observed.kind === "ready"
-            ? { kind: "ready" }
-            : { kind: "refused", refusal: observed.refusal };
-    }
-    catch (error) {
-        return { kind: "failed", diagnostic: expectedOperationalDiagnostic(error) };
-    }
-}
-async function runFencedPlacement(repository, input, protocol) {
+async function runFencedPlacement(repository, input, protocol, hereWorkspacePath) {
     for (let index = 0; index < protocol.attempts.length; index += 1) {
         const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
         if (prepared.kind === "refused")
@@ -52,7 +40,7 @@ async function runFencedPlacement(repository, input, protocol) {
                 observed,
             };
         }
-        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target);
+        const physical = await prepareTargetPlacement(repository, state, prepared.offer.target, hereWorkspacePath);
         if (physical.kind === "refused")
             return physical;
         const result = await admitDecidedOffer({
@@ -74,7 +62,7 @@ async function runFencedPlacement(repository, input, protocol) {
     return { kind: "exhausted" };
 }
 /** Hold the existing target-placement fence for one owner callback. */
-async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
+export async function runUnderTargetPlacementFence(repository, target, run, onReleaseFailure) {
     let held;
     try {
         held = await acquireTargetPlacementFence(repository, target);
@@ -123,7 +111,8 @@ function isDeliveryMissing(result) {
     return result.kind === "refused" && result.refusal.kind === "delivery-missing";
 }
 /** Run the sole placement adjudicator inside the target's physical fence. */
-export async function admitPlacement(channel, repository, target, input, onDeliveryMissing) {
+export async function admitPlacement(admission) {
+    const { channel, repository, target, placement: input, hereWorkspacePath, onDeliveryMissing } = admission;
     const attempts = mintAttempts({ entryCount: 1 });
     const protocol = {
         input,
@@ -137,7 +126,7 @@ export async function admitPlacement(channel, repository, target, input, onDeliv
     if (target === undefined)
         return await runProtocol(protocol);
     return await runUnderTargetPlacementFence(repository, target, async () => {
-        const result = await runFencedPlacement(repository, input, protocol);
+        const result = await runFencedPlacement(repository, input, protocol, hereWorkspacePath);
         if (onDeliveryMissing === undefined || !isDeliveryMissing(result))
             return result;
         return await onDeliveryMissing() ?? result;

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

@@ -1,8 +1,8 @@
 import type { ContractTargetLag, ContractWorkspaceObservation } from "../../git/workspace.js";
-import type { GitRepository } from "../../git/repository.js";
+import type { GitRepository } from "../../git/process.js";
 import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
-import type { ContractId, ContractState, DeliverData, SnapshotId } from "../../core/facts/types.js";
+import type { ContractId, ContractState, DeliverData, JournalEntry, SnapshotId } from "../../core/facts/types.js";
 export type ContractPhase = "waiting" | "bound" | "pending-delivery" | "claimed" | "abandoned";
 export type ContractDisposition = "active" | "terminal";
 export type ContractGateCurrent = GateCurrent;
@@ -11,11 +11,22 @@ export type ContractGateReport = Readonly<{
     current: ContractGateCurrent;
 }>;
 export type { ContractTargetLag, ContractWorkspaceObservation };
+export type HereWorkspaceObservationResolution = Readonly<{
+    kind: "appointed";
+    path: string;
+}> | Readonly<{
+    kind: "unappointed";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+}>;
+export type HereWorkspaceObservationResolver = (contractId: ContractId) => Promise<HereWorkspaceObservationResolution>;
 export type ContractRow = Readonly<{
     id: ContractId;
     title: string | null;
     phase: ContractPhase;
     phaseAt: string;
+    lastJournalAt: string;
     disposition: ContractDisposition;
     workspace: "worktree" | "here";
     worktreePath: string | null;
@@ -45,9 +56,10 @@ export type ContractObservation = Readonly<{
     row: ContractRow;
 }>;
 export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "delivery" | "bound">, bindAt: string): string;
+export declare function lastJournalAtFor(entries: readonly Pick<JournalEntry, "at">[]): string;
 /** Build the Contract board from one immutable git observation. */
-export declare function readContractBoard(observation: GitReadObservation, selected?: ContractId): Promise<ContractBoard>;
+export declare function readContractBoard(observation: GitReadObservation, selected?: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractBoard>;
 /** Observe one Contract and its target from one fresh ref epoch. */
-export declare function readContractObservation(observation: GitReadObservation, id: ContractId): Promise<ContractObservation>;
+export declare function readContractObservation(observation: GitReadObservation, id: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractObservation>;
 /** Observe one Contract and its target from one fresh ref epoch. */
-export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId): Promise<ContractObservation>;
+export declare function readContractObservationAt(repository: GitRepository, channel: GitDecodeChannel, id: ContractId, resolveHereWorkspace?: HereWorkspaceObservationResolver): Promise<ContractObservation>;

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

@@ -27,6 +27,12 @@ function phaseFor(state) {
 export function phaseAtFor(state, bindAt) {
     return state.terminal?.at ?? state.delivery?.at ?? state.bound?.at ?? bindAt;
 }
+export function lastJournalAtFor(entries) {
+    const last = entries.at(-1);
+    if (last === undefined)
+        throw new Error("present Contract journal is empty");
+    return last.at;
+}
 async function managedWorkspaceFacts(repository, state, register, targetObservation) {
     const appointed = appointmentFor(register, state.id);
     if (appointed === undefined) {
@@ -43,31 +49,52 @@ async function managedWorkspaceFacts(repository, state, register, targetObservat
     ]);
     return { appointed, workspaceObservation, targetLag };
 }
-async function hereWorkspaceFacts(repository, targetObservation) {
+async function hereWorkspaceFacts(repository, contractId, targetObservation, resolveHereWorkspace) {
+    const resolved = resolveHereWorkspace === undefined
+        ? { kind: "unappointed" }
+        : await resolveHereWorkspace(contractId);
+    if (resolved.kind === "failed") {
+        return {
+            appointed: undefined,
+            workspaceObservation: { kind: "failed", diagnostic: resolved.diagnostic },
+            targetLag: targetObservation === null ? { kind: "none" } : { kind: "unknown" },
+        };
+    }
+    if (resolved.kind === "unappointed") {
+        return {
+            appointed: undefined,
+            workspaceObservation: { kind: "unappointed" },
+            targetLag: targetObservation === null ? { kind: "none" } : { kind: "unknown" },
+        };
+    }
     const [workspaceObservation, targetLag] = await Promise.all([
-        observeWorkspace(repository, { kind: "here" }, repository.effectiveCwd),
-        observeTargetLag(repository, repository.effectiveCwd, targetObservation?.head),
+        observeWorkspace(repository, { kind: "here" }, resolved.path),
+        observeTargetLag(repository, resolved.path, targetObservation?.head),
     ]);
     return { appointed: undefined, workspaceObservation, targetLag };
 }
-async function rowFor(repository, state, bindAt, targetObservation, register) {
+async function rowFor(input) {
+    const { repository, state, bindAt, lastJournalAt, targetObservation, register, resolveHereWorkspace } = input;
     const workspace = state.coordinates.workspace;
     const gates = gateReports(state);
     const { appointed, workspaceObservation, targetLag } = workspace === "worktree"
         ? await managedWorkspaceFacts(repository, state, register, targetObservation)
-        : await hereWorkspaceFacts(repository, targetObservation);
+        : await hereWorkspaceFacts(repository, state.id, targetObservation, resolveHereWorkspace);
     return {
         id: state.id,
         title: titleFor(state),
         phase: phaseFor(state),
         phaseAt: phaseAtFor(state, bindAt),
+        lastJournalAt,
         disposition: state.terminal === null ? "active" : "terminal",
         workspace,
         worktreePath: appointed === undefined ? null : worktreePath(repository, appointed.place),
         workspaceObservation,
         target: state.coordinates.target ?? null,
         targetLag,
-        delivery: state.delivery?.data ?? null,
+        delivery: state.delivery === null || state.currentIntegration === null
+            ? null
+            : { ...state.delivery.data, integration: state.currentIntegration },
         targetObservation,
         gates: {
             reports: gates.reports.map((report) => ({ gate: report.gate, current: report.current })),
@@ -76,9 +103,9 @@ async function rowFor(repository, state, bindAt, targetObservation, register) {
     };
 }
 /** Build the Contract board from one immutable git observation. */
-export async function readContractBoard(observation, selected) {
+export async function readContractBoard(observation, selected, resolveHereWorkspace) {
     if (selected !== undefined) {
-        const contract = await readContractObservation(observation, selected);
+        const contract = await readContractObservation(observation, selected, resolveHereWorkspace);
         return {
             root: observation.repository.primaryWorktree,
             state: observation.snapshot.commit,
@@ -93,12 +120,21 @@ export async function readContractBoard(observation, selected) {
             continue;
         const state = value.state;
         const bindAt = value.entries[0].at;
-        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor(observation.repository, state, bindAt, target, register)));
+        const lastJournalAt = lastJournalAtFor(value.entries);
+        rows.push(observeDeliveryTargetAt(observation, state).then((target) => rowFor({
+            repository: observation.repository,
+            state,
+            bindAt,
+            lastJournalAt,
+            targetObservation: target,
+            register,
+            ...(resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace }),
+        })));
     }
     return { root: observation.repository.primaryWorktree, state: observed.snapshot, rows: await Promise.all(rows) };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
-export async function readContractObservation(observation, id) {
+export async function readContractObservation(observation, id, resolveHereWorkspace) {
     const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);
     const record = observed.journals.get(id);
     if (record === undefined)
@@ -108,10 +144,18 @@ export async function readContractObservation(observation, id) {
         ? { kind: "missing", id }
         : {
             kind: "present",
-            row: await rowFor(observation.repository, state, record.entries[0].at, await observeDeliveryTargetAt(observation, state), await readPlaceRegister(observation.repository)),
+            row: await rowFor({
+                repository: observation.repository,
+                state,
+                bindAt: record.entries[0].at,
+                lastJournalAt: lastJournalAtFor(record.entries),
+                targetObservation: await observeDeliveryTargetAt(observation, state),
+                register: await readPlaceRegister(observation.repository),
+                ...(resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace }),
+            }),
         };
 }
 /** Observe one Contract and its target from one fresh ref epoch. */
-export async function readContractObservationAt(repository, channel, id) {
-    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id));
+export async function readContractObservationAt(repository, channel, id, resolveHereWorkspace) {
+    return withContractReadObservationAt(repository, channel, id, async (observation) => await readContractObservation(observation, id, resolveHereWorkspace));
 }

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

@@ -0,0 +1,35 @@
+import { type ReconcileResult } from "../git/reconcile.js";
+import type { ContractId, ContractState } from "../core/facts/types.js";
+import type { WorktreeHooks } from "../git/hooks.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import type { MutationOperationInput, RepositoryScope } from "./operations.js";
+export type ReconcileReport = ReconcileResult;
+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;
+}>;
+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>;
+export {};

package/build/src/protocol/reconcile.js

@@ -0,0 +1,41 @@
+import { reconcile, reconcileBatch, reconcileObservationFailure } from "../git/reconcile.js";
+import { observeContractWorld } from "../git/observe.js";
+import { withGitReadObservation } from "../git/read-observation.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+export async function reconcileOperation(input) {
+    try {
+        const observation = await reconcile({
+            repository: input.scope,
+            channel: input.channel,
+            contractId: input.contractId,
+            hooks: input.hooks,
+            retryHooks: input.retryHooks,
+            ...(input.retainTerminalWorktree === undefined ? {} : { retainTerminalWorktree: input.retainTerminalWorktree }),
+            ...(input.place === undefined ? {} : { place: input.place }),
+        });
+        return { state: observation.state, report: observation.result };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        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 observation = await withGitReadObservation(input.scope, input.channel, async (read) => await observeContractWorld(read));
+    const contracts = (await reconcileBatch(input.scope, input.channel, observation.contracts.keys(), {
+        hooks: input.hooks,
+        retryHooks: input.retryHooks,
+        retainTerminalWorktree: input.retainTerminalWorktree ?? false,
+        ...(input.places === undefined ? {} : { places: input.places }),
+    })).map((item) => ({
+        contractId: item.contract,
+        state: item.state,
+        report: item.result,
+    }));
+    return { contracts };
+}

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

@@ -0,0 +1,31 @@
+import type { ActorId, ContractId, ReintegratedData } from "../core/facts/types.js";
+import { type ReintegrateRefusal } from "../core/verbs/reintegrate.js";
+import { type IntegrationPreparationRefusal } from "../git/integration.js";
+import type { GitRepository } from "../git/process.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type AcceptedAdmission } from "./attempt.js";
+import type { ProtocolTerminal } from "./run.js";
+import { type PlacementExecutionFailure } from "./placement.js";
+type TargetMissing = Readonly<{
+    kind: "target-missing";
+    contractId: ContractId;
+}>;
+export type ReintegrationRefusal = ReintegrateRefusal | TargetMissing | IntegrationPreparationRefusal;
+export type ReintegrationResult = (AcceptedAdmission & Readonly<{
+    value: ReintegratedData;
+}>) | Readonly<{
+    kind: "refused";
+    refusal: ReintegrationRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: ProtocolTerminal;
+}> | PlacementExecutionFailure;
+type ReintegrationInput = Readonly<{
+    channel: GitDecodeChannel;
+    repository: GitRepository;
+    contractId: ContractId;
+    target: string;
+    actor?: ActorId;
+}>;
+export declare function reintegrateOperation(input: ReintegrationInput): Promise<ReintegrationResult>;
+export {};

package/build/src/protocol/reintegrate.js

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

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

@@ -0,0 +1,34 @@
+import { type WorkspaceDirtyDelta } from "../git/tender.js";
+import type { AttestationData, ContractState, DeliverData } from "../core/facts/types.js";
+import { type AttestationRefusal } from "../core/verbs/attestation.js";
+import { type CompletionEvidence } from "./completion.js";
+import type { DocumentDerivation, IntentOutcome, MutationOperationInput, RepositoryScope } from "./operations.js";
+type ReviewPreparationRefusal = Readonly<{
+    kind: "worktree-missing";
+    contractId: import("../core/facts/types.js").ContractId;
+}> | import("../git/tender.js").DirtyWorkspaceRefusal;
+type ReviewRefusal = AttestationRefusal | ReviewPreparationRefusal;
+type ReviewOperationInput = MutationOperationInput & Readonly<{
+    verdict: AttestationData["verdict"];
+    summary?: string;
+    deriveDocument?: (state: ContractState) => DocumentDerivation;
+}>;
+export type ReviewValue = CompletionEvidence & Readonly<{
+    workspace?: WorkspaceDirtyDelta;
+}>;
+export declare function prepareReview(repository: RepositoryScope, stage: Readonly<{
+    contractId: import("../core/facts/types.js").ContractId;
+    coordinates: ContractState["coordinates"];
+    workspacePath?: string;
+}>): Promise<{
+    kind: "prepared";
+    data: Readonly<{
+        changeId: DeliverData["integration"]["changeId"];
+        workspace?: WorkspaceDirtyDelta;
+    }>;
+} | {
+    kind: "refused";
+    refusal: ReviewPreparationRefusal;
+}>;
+export declare function reviewOperation(input: ReviewOperationInput): Promise<IntentOutcome<ReviewValue, ReviewRefusal>>;
+export {};