@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/library/continuation.js

@@ -1,64 +1,28 @@
-import { contractId } from "../core/facts/types.js";
 import { observeActiveContractWorld } from "../git/observe.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { reconcileDependentWorktree } from "../git/reconcile.js";
 import { worktreePath } from "../git/workspace.js";
 import { completeCandidate } from "../protocol/completion.js";
-import { contractCheckpoint, executionStop } from "../protocol/progress.js";
+import { contractCheckpoint, isOperationalStop, executionStop, } from "../protocol/progress.js";
 import { observeContractAt } from "../git/observe.js";
-import { decodeGitReconcileLag } from "../git/result-codec.js";
-import { executionStopSchema } from "./execution-result.js";
-import { decodePlacementStop, decodeVerificationStop } from "../protocol/result-codec.js";
-import { ownerSchema } from "./result-codec.js";
+import { gitReconcileLagSchema } from "../git/reconcile.js";
+import { executionStopSchema } from "../protocol/progress.js";
+import { contractIdSchema, placementStopSchema, verificationStopSchema } from "../protocol/operations.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-export function decodeContinuationReport(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed continuation report");
-    const object = value;
-    if (!Array.isArray(object.claimed) || !Array.isArray(object.stopped))
-        throw new Error("malformed continuation report");
-    if (Object.keys(object).some((key) => key !== "claimed" && key !== "stopped"))
-        throw new Error("malformed continuation report");
-    return {
-        claimed: object.claimed.map((id) => contractId(String(id))),
-        stopped: object.stopped.map((item) => {
-            if (item === null || typeof item !== "object" || Array.isArray(item))
-                throw new Error("malformed continuation report");
-            const stopped = item;
-            if (Object.keys(stopped).some((key) => key !== "contractId" && key !== "stop"))
-                throw new Error("malformed continuation report");
-            const stopValue = stopped.stop;
-            const alreadyTerminal = stopValue !== null &&
-                typeof stopValue === "object" &&
-                !Array.isArray(stopValue) &&
-                stopValue.kind === "already-terminal" &&
-                Object.keys(stopValue).length === 1;
-            return {
-                contractId: contractId(String(stopped.contractId)),
-                stop: alreadyTerminal ? { kind: "already-terminal" } : decodeContinuationStop(stopValue),
-            };
-        }),
-    };
-}
-export const continuationReportSchema = ownerSchema(decodeContinuationReport, "expected continuation report");
-function decodeContinuationStop(value) {
-    if (value !== null && typeof value === "object" && "kind" in value) {
-        if (value.kind === "execution-stopped")
-            return executionStopSchema.parse(value);
-        if (value.kind === "physical-lag" &&
-            "lags" in value &&
-            Array.isArray(value.lags) &&
-            Object.keys(value).length === 2) {
-            return { kind: "physical-lag", lags: value.lags.map(decodeGitReconcileLag) };
-        }
-    }
-    try {
-        return decodePlacementStop(value);
-    }
-    catch {
-        return decodeVerificationStop(value);
-    }
-}
+import { z } from "zod";
+const continuationStopSchema = z.union([
+    placementStopSchema,
+    verificationStopSchema,
+    executionStopSchema,
+    z.object({ kind: z.literal("already-terminal") }).strict(),
+    z.object({ kind: z.literal("physical-lag"), lags: z.array(gitReconcileLagSchema).readonly() }).strict(),
+]);
+export const continuationReportSchema = z
+    .object({
+    claimed: z.array(contractIdSchema).readonly(),
+    stopped: z.array(z.object({ contractId: contractIdSchema, stop: continuationStopSchema }).strict()).readonly(),
+})
+    .strict();
 function reverseDependents(world) {
     const index = new Map();
     for (const record of world.contracts.values()) {
@@ -103,6 +67,8 @@ async function attemptDependent(input, id, predecessor) {
         return await continueCandidate(input, id, predecessor);
     }
     catch (error) {
+        if (!isOperationalStop(error, input.signal))
+            throw error;
         const stop = executionStop(id, "continuation", error, input.signal);
         input.progress.recordStop(stop);
         return { kind: "stopped-before-node", stop };
@@ -113,6 +79,10 @@ export async function continueDeliveredDependents(input) {
     const primary = input.completed.checkpoint.state.id;
     const claimed = [];
     const stopped = [];
+    const retain = () => input.progress.recordContinuation(primary, { claimed: [...claimed], stopped: [...stopped] });
+    // The primary candidate's own conclusions are retained by completion before this walk discovers
+    // anything; every sibling attempt is retained here before the next one is awaited.
+    retain();
     try {
         input.signal?.throwIfAborted();
         const world = await withGitReadObservation(input.scope, input.channel, observeActiveContractWorld);
@@ -134,6 +104,7 @@ export async function continueDeliveredDependents(input) {
                 if (result.kind === "completed") {
                     claimed.push(id);
                     newlyClaimed.add(id);
+                    retain();
                     queue.push({ contractId: id, target: result.evidence.completion.integration });
                 }
                 else {
@@ -142,15 +113,19 @@ export async function continueDeliveredDependents(input) {
                         contractId: id,
                         stop: "refusal" in stop && stop.refusal.kind === "terminal" ? { kind: "already-terminal" } : stop,
                     });
+                    retain();
                 }
             }
         }
         return attempted.size === 0 ? undefined : { claimed, stopped };
     }
     catch (error) {
+        if (!isOperationalStop(error, input.signal))
+            throw error;
         const stop = executionStop(primary, "continuation", error, input.signal);
         input.progress.recordStop(stop);
         stopped.push({ contractId: primary, stop });
+        retain();
         return { claimed, stopped };
     }
 }

package/build/src/library/contract-composition.d.ts

@@ -0,0 +1,40 @@
+/** @architectureCompositionRoot */
+import { type LibraryExecution } from "../akuma/requests.js";
+import type { ContractObservation } from "../protocol/read/status.js";
+import type { BindOutcome } from "./contract-outcomes.js";
+import type { BindInput, ContractList, ContractListInput, ContractObservationInput, KeiyakuSelectInput, LocalContractComposition } from "./contract-types.js";
+import type { Keiyaku, createKeiyakuHandle } from "./keiyaku.js";
+import { type ReconcileCompletion, type RepoReconcileReport } from "./reconcile.js";
+import { type Repo } from "./repo.js";
+export type ReconcileInput = Readonly<{
+    repo: Repo;
+    contract?: string;
+    retryHooks?: boolean;
+}>;
+interface KeiyakuLibraryReconcile {
+    (input: ReconcileInput & Readonly<{
+        contract: string;
+    }>): Promise<ReconcileCompletion>;
+    (input: ReconcileInput & Readonly<{
+        contract?: undefined;
+    }>): Promise<RepoReconcileReport>;
+    (input: ReconcileInput): Promise<ReconcileCompletion | RepoReconcileReport>;
+}
+export type KeiyakuLibrary = Readonly<{
+    bind(input: BindInput): Promise<BindOutcome>;
+    select(input: KeiyakuSelectInput): Keiyaku;
+    list(input: ContractListInput): Promise<ContractList>;
+    observe(input: ContractObservationInput): Promise<ContractObservation>;
+    reconcile: KeiyakuLibraryReconcile;
+}>;
+/**
+ * The one private Contract composition constructor. `Keiyaku.with` fixes local execution; CLI and
+ * Body pass their captured internal channel explicitly here instead of a second constructor. The
+ * carrier is a positional argument, never a field of the public construction input, so no runtime
+ * value reaching the public surface can select a private channel.
+ */
+export declare function composeContractLibrary(execution: LibraryExecution, createHandle: typeof createKeiyakuHandle, input?: LocalContractComposition): KeiyakuLibrary;
+export declare function listKeiyaku(input: ContractListInput): Promise<ContractList>;
+export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
+export declare function readContractValue<Value>(operation: () => Promise<Value>): Promise<Value>;
+export {};

package/build/src/library/contract-composition.js

@@ -0,0 +1,105 @@
+/** @architectureCompositionRoot */
+import { localExecutionContext } from "../akuma/requests.js";
+import { contractId } from "../core/facts/types.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { contractCatalogueOperation, contractObservationOperation, contractsOperation, } from "../protocol/operations.js";
+import { bindKeiyaku } from "./contract-creation.js";
+import { captureLocalContractComposition, derivedHooks, } from "./contract-settings.js";
+import { requireInput } from "./input.js";
+import { KeiyakuError, errorCategory } from "./outcome.js";
+import { completeReconcile, completeRepoReconcile, } from "./reconcile.js";
+import { scopeForRepo } from "./repo.js";
+/**
+ * The one private Contract composition constructor. `Keiyaku.with` fixes local execution; CLI and
+ * Body pass their captured internal channel explicitly here instead of a second constructor. The
+ * carrier is a positional argument, never a field of the public construction input, so no runtime
+ * value reaching the public surface can select a private channel.
+ */
+export function composeContractLibrary(execution, createHandle, input) {
+    const composition = captureLocalContractComposition(input);
+    return Object.freeze({
+        bind: (operation) => bindKeiyaku(operation, createHandle, execution, composition),
+        select: (operation) => selectKeiyaku(operation, createHandle, execution, composition),
+        list: (operation) => listKeiyaku(operation),
+        observe: (operation) => observeKeiyaku(operation),
+        reconcile: reconcileOperation(composition),
+    });
+}
+function selectKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
+    const values = requireInput(input, "Keiyaku.with().select input");
+    const scope = scopeForRepo(values.repo);
+    if (typeof values.id !== "string")
+        throw new TypeError("contract ID must be a string");
+    return createHandle(contractId(values.id), scope, execution, composition);
+}
+/**
+ * The one public repair entry: an explicit Repo proves the Git world, the captured composition
+ * supplies its Settings-derived hooks, and the same operation-local retryHooks choice stays
+ * available. Omitted contract reconciles the complete world; a supplied one reconciles that
+ * addressed Contract.
+ */
+function reconcileOperation(composition) {
+    function run(input) {
+        return reconcileKeiyaku(input, composition);
+    }
+    return run;
+}
+async function reconcileKeiyaku(input, composition = captureLocalContractComposition()) {
+    const values = requireInput(input, "Keiyaku.with().reconcile input", ["repo", "contract", "retryHooks"]);
+    const scope = scopeForRepo(values.repo);
+    const contract = values.contract;
+    if (contract !== undefined && typeof contract !== "string")
+        throw new TypeError("contract must be a string");
+    if (values.retryHooks !== undefined && typeof values.retryHooks !== "boolean")
+        throw new TypeError("retryHooks must be a boolean");
+    const options = { scope, hooks: derivedHooks(composition), retryHooks: values.retryHooks ?? false };
+    if (contract === undefined) {
+        return await withGitDecodeChannel(scope, (channel) => completeRepoReconcile({ ...options, channel }));
+    }
+    const id = contractId(contract);
+    return await readContractValue(() => withGitDecodeChannel(scope, (channel) => completeReconcile({ ...options, channel, contractId: id })));
+}
+export async function listKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.with().list input");
+    for (const key of Object.keys(values)) {
+        if (key !== "repo" && key !== "limit")
+            throw new TypeError(`Keiyaku.with().list input has unknown field: ${key}`);
+    }
+    const scope = scopeForRepo(values.repo);
+    if (values.limit === undefined) {
+        const board = await readContractValue(() => withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel })));
+        return { ...board, hasMore: false };
+    }
+    if (typeof values.limit !== "number")
+        throw new TypeError("Contract list limit must be a number");
+    return readContractValue(() => withGitDecodeChannel(scope, (channel) => contractCatalogueOperation({ scope, channel, limit: values.limit })));
+}
+export async function observeKeiyaku(input) {
+    const values = requireInput(input, "Keiyaku.observe input");
+    for (const key of Object.keys(values))
+        if (key !== "repo" && key !== "id")
+            throw new TypeError(`Keiyaku.observe input has unknown field: ${key}`);
+    const scope = scopeForRepo(values.repo);
+    if (typeof values.id !== "string")
+        throw new TypeError("contract ID must be a string");
+    let id;
+    try {
+        id = contractId(values.id);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
+    }
+    return readContractValue(() => withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id })));
+}
+export async function readContractValue(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof KeiyakuError)
+            throw error;
+        throw new KeiyakuError(errorCategory(error), error instanceof Error ? error.message : String(error), {
+            cause: error,
+        });
+    }
+}

package/build/src/library/contract-creation.d.ts

@@ -0,0 +1,7 @@
+/** @architectureCompositionRoot */
+import { type ExecutionContext } from "../akuma/requests.js";
+import type { BindOutcome } from "./contract-outcomes.js";
+import { type LocalContractCompositionCapture } from "./contract-settings.js";
+import type { BindInput } from "./contract-types.js";
+import type { createKeiyakuHandle } from "./keiyaku.js";
+export declare function bindKeiyaku(input: BindInput, createHandle: typeof createKeiyakuHandle, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Promise<BindOutcome>;

package/build/src/library/contract-creation.js

@@ -0,0 +1,192 @@
+/** @architectureCompositionRoot */
+import { localExecutionContext } from "../akuma/requests.js";
+import { decodeContractDocument } from "../body/decode.js";
+import { regionWarnings } from "../body/region.js";
+import { contractId } from "../core/facts/types.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { executionStop, isOperationalFailure, isOperationalStop } from "../protocol/progress.js";
+import { readManagedWorktreeAppointment } from "../workspace-place.js";
+import { admitForkBindWithAppointment, prepareMarkdownBind } from "./bind.js";
+import { acceptedOutcome, conclusions, expected, retainAdmission } from "./contract-outcomes.js";
+import { captureLocalContractComposition, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
+import { actorOption, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
+import { InvocationAccumulator } from "./invocation.js";
+import { project, validated } from "./outcome.js";
+import { completeReconcile } from "./reconcile.js";
+import { observeRegion } from "./region.js";
+import { scopeForRepo } from "./repo.js";
+function bindInput(input, composition) {
+    return validated(() => {
+        const values = requireInput(input, "Keiyaku.bind input");
+        const forkOf = values.forkOf;
+        const allowed = forkOf === undefined
+            ? ["repo", "markdown", "task", "target", "workspace", "actor", "after", "gates"]
+            : ["repo", "forkOf", "target", "workspace", "actor"];
+        requireInput(input, "Keiyaku.bind input", allowed);
+        if ((values.workspace ?? "worktree") !== "worktree")
+            throw new TypeError("workspace must be worktree");
+        if (values.target !== undefined && typeof values.target !== "string")
+            throw new TypeError("target must be a string");
+        const actor = actorOption(values.actor);
+        const document = forkOf === undefined ? parseMarkdown(requireMarkdown(values.markdown)) : undefined;
+        if (forkOf !== undefined) {
+            if (typeof forkOf !== "string")
+                throw new TypeError("forkOf must be a ContractId");
+        }
+        return {
+            forkOf: forkOf === undefined ? undefined : contractId(forkOf),
+            scope: scopeForRepo(values.repo),
+            document,
+            actor,
+            target: values.target,
+            task: forkOf === undefined ? taskOption(values.task) : undefined,
+            gates: forkOf === undefined ? derivedGates(composition, gateNames(values.gates)) : undefined,
+            after: forkOf === undefined ? normalizedList(values.after, "after", contractId) : undefined,
+        };
+    });
+}
+export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
+    const prepared = bindInput(input, composition);
+    const hooks = derivedHooks(composition);
+    const { forkOf, scope, document, target, actor } = prepared;
+    const handle = (id) => createHandle(id, scope, execution, composition);
+    const accumulator = new InvocationAccumulator();
+    const projection = await (async () => {
+        let completed;
+        let retirement;
+        try {
+            return await withGitDecodeChannel(scope, async (channel) => {
+                completed = await (async () => {
+                    if (forkOf !== undefined) {
+                        const fork = await admitForkBindWithAppointment({
+                            scope,
+                            channel,
+                            progress: accumulator,
+                            sourceId: forkOf,
+                            ...(target === undefined ? {} : { target }),
+                            ...actor,
+                        });
+                        if (fork.kind === "refused")
+                            return { kind: "refused", refusal: fork.refusal };
+                        const admission = fork.admission;
+                        if (admission.kind !== "accepted")
+                            return expected(undefined, admission);
+                        const id = admission.value.contractId;
+                        accumulator.extendConclusions(id, { keiyaku: handle(id) });
+                        const value = await bindComplete(accumulator, id, scope, channel, admission, hooks, () => observeRegion(scope, channel, id, fork.document.region).then((region) => bindValue(handle(id), region, [])));
+                        return acceptedOutcome("bind", id, accumulator, value);
+                    }
+                    if (document === undefined)
+                        throw new Error("Markdown bind requires its prepared document");
+                    return await markdownBind(prepared, document, hooks, scope, channel, accumulator, handle);
+                })();
+                return completed;
+            }, (error) => {
+                retirement = { error };
+                const id = accumulator.snapshot().facts.find((fact) => fact.kind === "bind")?.contract;
+                if (id !== undefined)
+                    accumulator.recordChannelRetirement(id, error);
+            });
+        }
+        catch (error) {
+            if (retirement !== undefined &&
+                error === retirement.error &&
+                completed?.kind === "accepted" &&
+                isOperationalFailure(error))
+                return completed;
+            const contract = accumulator.snapshot().facts.find((fact) => fact.kind === "bind")?.contract;
+            return { kind: "failed", ...(contract === undefined ? {} : { contract }), error };
+        }
+    })();
+    const projected = project("bind", accumulator.snapshot(), projection);
+    if (projected.kind === "failed")
+        throw projected.error;
+    return projected.outcome;
+}
+function bindValue(keiyaku, region, warnings, workspace, appointmentLag) {
+    const base = {
+        keiyaku,
+        ...(workspace === undefined ? {} : { workspace }),
+        ...(warnings.length === 0 ? {} : { warnings }),
+        ...region,
+    };
+    void appointmentLag;
+    return base;
+}
+// eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
+async function bindComplete(accumulator, id, scope, channel, leading, hooks, value) {
+    retainAdmission(accumulator, id, leading, false);
+    await reconcileAll(accumulator, id, scope, channel, hooks);
+    try {
+        const appointment = await readManagedWorktreeAppointment(scope, id);
+        if (appointment.kind === "appointed")
+            accumulator.extendConclusions(id, {
+                workspace: { kind: "worktree", path: appointment.path },
+            });
+    }
+    catch (error) {
+        if (!isOperationalStop(error, scope.signal))
+            throw error;
+        accumulator.recordStop(executionStop(id, "reconciliation", error, scope.signal));
+    }
+    const built = { ...(await value()), ...accumulator.conclusions(id) };
+    accumulator.extendConclusions(id, conclusions(built));
+    return built;
+}
+async function reconcileAll(accumulator, id, scope, channel, hooks) {
+    for (const contract of [...new Set([id, ...accumulator.snapshot().affected])]) {
+        try {
+            accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
+            const report = await (async () => {
+                try {
+                    return await completeReconcile({
+                        scope,
+                        channel,
+                        contractId: contract,
+                        hooks,
+                        retryHooks: false,
+                        progress: accumulator,
+                    });
+                }
+                finally {
+                    accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
+                }
+            })();
+            void report;
+        }
+        catch (error) {
+            if (!isOperationalStop(error, scope.signal))
+                throw error;
+            accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
+        }
+    }
+}
+// eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
+async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle) {
+    const { task, target, actor, gates, after } = prepared;
+    if (gates === undefined || after === undefined)
+        throw new Error("Markdown bind requires prepared terms");
+    const targetSelection = target !== undefined ? { kind: "explicit", target } : { kind: "targetless" };
+    const admission = await prepareMarkdownBind({
+        scope,
+        channel,
+        document,
+        gates,
+        progress: accumulator,
+        after,
+        workspace: "worktree",
+        targetSelection,
+        ...(task === undefined ? {} : { task }),
+        ...actor,
+    });
+    const leading = admission.admission === null ? admission.result : admission.admission.result;
+    if (leading.kind !== "accepted")
+        return expected(undefined, leading);
+    const id = leading.value.contractId;
+    accumulator.extendConclusions(id, { keiyaku: handle(id), warnings: regionWarnings(document.region) });
+    const value = await bindComplete(accumulator, id, scope, channel, leading, hooks, async () => bindValue(handle(id), await observeRegion(scope, channel, id, document.region), regionWarnings(document.region)));
+    return acceptedOutcome("bind", id, accumulator, value);
+}
+function parseMarkdown(markdown) {
+    return decodeContractDocument(markdown, { requireTimeout: true });
+}

package/build/src/library/contract-execution.d.ts

@@ -1,41 +1,30 @@
-import type { ExecutionObserver } from "../protocol/execution-observation.js";
-import type { ActorId, ContractId } from "../core/facts/types.js";
-import { type GitDecodeChannel } from "../git/read-observation.js";
-import { type IntegrationConflictMaterialized } from "../protocol/deliver.js";
+import { type ExecutionContext } from "../akuma/requests.js";
+import { type ContractId } from "../core/facts/types.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-import { ExecutionProgress } from "../protocol/progress.js";
-import type { WorktreeHooks } from "./configuration.js";
-import type { DeliveryValue } from "./delivery.js";
-import { type MutationResult, type Review } from "./mutation.js";
-import { type MutationOperation } from "./execution-result.js";
-type CommonExecutionInput = Readonly<{
-    scope: RepositoryScope;
-    contractId: ContractId;
-    actor?: ActorId;
-    signal?: AbortSignal;
-    hooks: WorktreeHooks;
-    observe?: ExecutionObserver;
-}>;
-export type DeliveryExecutionInput = CommonExecutionInput & Readonly<{
-    message?: string;
-    requireBranchesToBeUpToDate: boolean;
-    includeDirty: boolean;
-    materializeConflict: boolean;
-    overwrite?: boolean;
-}>;
-export type AttestationVerdict = "satisfied" | "unsatisfied";
-export type ReviewExecutionInput = CommonExecutionInput & Readonly<{
-    verdict: AttestationVerdict;
-    summary?: string;
-}>;
-type ExecutionContext = CommonExecutionInput & Readonly<{
-    channel: GitDecodeChannel;
-    progress: ExecutionProgress;
-}>;
-/** The channel's own retirement cannot hide an already returned admission. */
-export declare function withContractExecution<Result extends MutationResult<unknown> | IntegrationConflictMaterialized>(input: CommonExecutionInput, operation: MutationOperation, run: (context: ExecutionContext) => Promise<Result>): Promise<Result>;
-/** Review records testimony, then the same shared node judges automatic placement. */
-export declare function executeLocalReview(input: ReviewExecutionInput): Promise<MutationResult<Review>>;
-/** Delivery admits a candidate; completion and dependent continuation remain automatic. */
-export declare function executeLocalDelivery(input: DeliveryExecutionInput): Promise<MutationResult<DeliveryValue> | IntegrationConflictMaterialized>;
-export {};
+import type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditInput, AuditOutcome, DeliverOutcome, MutationObservation, ReviewOutcome } from "./contract-outcomes.js";
+import { type LocalContractCompositionCapture } from "./contract-settings.js";
+import type { AbandonInput, AmendInput, ArcInput, DeliverInput, ReviewInput } from "./contract-types.js";
+export declare class ContractExecution {
+    private readonly seat;
+    constructor(seat: Readonly<{
+        id: ContractId;
+        scope: RepositoryScope;
+        execution: ExecutionContext;
+        composition: LocalContractCompositionCapture;
+    }>);
+    private get id();
+    private get scope();
+    private get execution();
+    private get composition();
+    amend(input: AmendInput): Promise<AmendOutcome>;
+    /** One promise with an optional observation callback; observation never delays custody. */
+    deliver(input?: DeliverInput, options?: MutationObservation): Promise<DeliverOutcome>;
+    review(input: ReviewInput, options?: MutationObservation): Promise<ReviewOutcome>;
+    abandon(input?: AbandonInput): Promise<AbandonOutcome>;
+    arc(input: ArcInput): Promise<ArcOutcome>;
+    audit(input?: AuditInput, options?: MutationObservation): Promise<AuditOutcome>;
+    /** One accumulator before the first admission-capable await, one projector after teardown. */
+    private local;
+    private conclude;
+    private reconcileContracts;
+}