@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/library/configuration.d.ts

@@ -1,26 +1,17 @@
-import type { Settings } from "../settings.js";
+import { SettingsError, type Settings } from "../settings.js";
+import type { WorktreeHooks } from "../git/hooks.js";
+export type { HookCommand, WorktreeHooks } from "../git/hooks.js";
 export type Gate = string;
 export type GatesFromInput = Readonly<{
     settings: Settings;
     name?: string;
 }>;
-export type HookCommand = Readonly<{
-    argv: readonly string[];
-    timeoutMs: number;
-}>;
-export type WorktreeHooks = Readonly<{
-    create: readonly HookCommand[];
-    destroy: readonly HookCommand[];
-}>;
-export type WorktreeHooksFromInput = Readonly<{
+export type RequireBranchesToBeUpToDateFromInput = Readonly<{
     settings: Settings;
 }>;
-export declare class SettingsError extends Error {
-    readonly kind = "settings";
-    constructor(message: string);
-}
+export { SettingsError };
 export declare function gatesFrom(input: GatesFromInput): readonly Gate[];
-export declare function worktreeHooksFrom(input: WorktreeHooksFromInput): WorktreeHooks;
+export declare function requireBranchesToBeUpToDateFrom(input: RequireBranchesToBeUpToDateFromInput): boolean;
 export declare function normalizedWorktreeHooks(value: unknown): WorktreeHooks;
 export declare const EMPTY_WORKTREE_HOOKS: WorktreeHooks;
 export declare function worktreeHooksOption(value: unknown): WorktreeHooks;

package/build/src/library/configuration.js

@@ -1,11 +1,6 @@
 import { gateWord } from "../core/facts/types.js";
-export class SettingsError extends Error {
-    kind = "settings";
-    constructor(message) {
-        super(message);
-        this.name = "SettingsError";
-    }
-}
+import { SettingsError } from "../settings.js";
+export { SettingsError };
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -62,22 +57,24 @@ function commands(value, coordinate, ErrorType) {
         throw new ErrorType(`${coordinate} must be an array`);
     return Object.freeze(value.map((item, index) => command(item, `${coordinate}[${index}]`, ErrorType)));
 }
-export function worktreeHooksFrom(input) {
+export function requireBranchesToBeUpToDateFrom(input) {
     if (!record(input))
-        throw new TypeError("worktreeHooksFrom input must be an object");
-    const view = input.settings.namespace("worktree");
+        throw new TypeError("requireBranchesToBeUpToDateFrom input must be an object");
+    const view = input.settings.namespace("git");
     if (view.kind === "failed")
         namespaceFailure(view);
     for (const entry of view.entries) {
-        if (entry.name !== "create" && entry.name !== "destroy") {
-            throw new SettingsError(`worktree has unknown entry: ${entry.name}`);
+        if (entry.name !== "requireBranchesToBeUpToDate") {
+            throw new SettingsError(`git has unknown entry: ${entry.name}`);
         }
     }
-    const value = (phase) => {
-        const selected = view.entries.find((entry) => entry.name === phase);
-        return selected === undefined ? Object.freeze([]) : commands(selected.value, `worktree.${phase}`, SettingsError);
-    };
-    return Object.freeze({ create: value("create"), destroy: value("destroy") });
+    const selected = view.entries.find((entry) => entry.name === "requireBranchesToBeUpToDate");
+    if (selected === undefined)
+        return false;
+    if (typeof selected.value !== "boolean") {
+        throw new SettingsError("git.requireBranchesToBeUpToDate must be a boolean");
+    }
+    return selected.value;
 }
 export function normalizedWorktreeHooks(value) {
     if (!record(value))

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

@@ -1,54 +1,42 @@
+import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
 import { type RegionObservation, type RegionOverlap } from "./region.js";
 import { type Gate, type WorktreeHooks } from "./configuration.js";
-import { type ChangeId, type ContractHead, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
+import { type ChangeId, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { type AuditReport, type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow, type DeliverValue, type FactKind, type IntentRefusal, type IntentRetry, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type TimelineEntry, type VerificationStop } from "../protocol/operations.js";
+import { type AuditReport, type ContractBoard, type ContractDisposition, type ContractGateCurrent, type ContractGateReport, type ContractObservation, type ContractPhase, type ContractRow, type FactKind, type PlacementStop, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope, type ReviewValue, type VerificationReuse, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
 import { type SettlementReport } from "../settlement/settle.js";
-import { type TaskHolder } from "../settlement/holder.js";
 import { type TaskId } from "../task/identity.js";
 import { Repo, type ReconcileInput } from "./repo.js";
-export { gatesFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
-export type { Gate, GatesFromInput, HookCommand, WorktreeHooks, WorktreeHooksFromInput } from "./configuration.js";
-export type { AuditReport, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, TimelineEntry, };
+import { type AuditInput } from "./audit.js";
+import { Delivery } from "./delivery.js";
+import { type MutationResult } from "./mutation.js";
+export { KeiyakuRefused, KeiyakuRetry, type ContractAppointmentRefusal, type KeiyakuRefusal, type KeiyakuRetryReason, } from "./refusal.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
+export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks } from "./configuration.js";
+export type { AuditReport, DeliveryPreparationRefusal, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, };
 export type { TaskId };
 export type { RegionOverlap };
 export type Fact = JournalEntry;
 export type ActorId = string;
 export type AttestationVerdict = "satisfied" | "unsatisfied";
 export type Review = ReviewValue;
-export type KeiyakuRefusal = IntentRefusal;
-export type KeiyakuRetryReason = IntentRetry;
-export type { PlacementStop, VerificationStop };
-export type TopologyEffect = ProtocolReconcileReport["effects"][number];
-export type Lag = ProtocolReconcileReport["lag"][number];
-export type MutationResult<Value> = Readonly<{
-    facts: readonly Fact[];
-    head: ContractHead;
-    value: Value;
-    effects: readonly TopologyEffect[];
-    lags: readonly Lag[];
-    settlement: SettlementReport;
-}>;
+export type { PlacementStop, VerificationReuse, VerificationStop };
+export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
+export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
+export type { MutationResult };
+export { Delivery };
 export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
     keiyaku: Keiyaku;
 } & RegionObservation>;
 export type AmendResult = Readonly<MutationResult<void> & RegionObservation & {
     documentDiff: string;
 }>;
-export type ReconcileReport = Readonly<ProtocolReconcileReport & {
+export type ReconcileReport = Readonly<{
+    effects: readonly TopologyEffect[];
+    lag: readonly Lag[];
     settlement: SettlementReport;
 }>;
 export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
-export declare class KeiyakuRefused extends Error {
-    readonly refusal: KeiyakuRefusal;
-    constructor(refusal: KeiyakuRefusal);
-    get code(): KeiyakuRefusal["kind"];
-}
-export declare class KeiyakuRetry extends Error {
-    readonly reason: KeiyakuRetryReason;
-    constructor(reason: KeiyakuRetryReason);
-    get code(): KeiyakuRetryReason["kind"];
-}
 export type BindInput = Readonly<{
     repo: Repo;
     markdown: string;
@@ -98,29 +86,17 @@ export type AbandonInput = ActorOptions & Readonly<{
 }>;
 export type DeliverInput = ActorOptions & Readonly<{
     message?: string;
+    requireBranchesToBeUpToDate?: boolean;
+    includeDirty?: boolean;
+    signal?: AbortSignal;
 }>;
-export type AuditInput = ActorOptions;
-declare class DeliveryHandle {
-    readonly snapshotId: SnapshotId;
-    readonly changeId: ChangeId;
-    readonly expectedPredecessor: SnapshotId;
-    private readonly readDiff;
-    readonly verification?: DeliverValue["verification"];
-    readonly placement?: DeliverValue["placement"];
-    readonly leak?: DeliverValue["leak"];
-    constructor(snapshotId: SnapshotId, changeId: ChangeId, expectedPredecessor: SnapshotId, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "verification" | "placement" | "leak">>);
-    diff(): Promise<string | null>;
-}
-export type Delivery = DeliveryHandle;
-export declare const Delivery: Readonly<{
-    prototype: DeliveryHandle;
-    [Symbol.hasInstance](value: unknown): boolean;
-}>;
+export type { AuditInput };
 export declare class KeiyakuHandle {
     private readonly id;
     private readonly scope;
     constructor(id: ContractId, scope: RepositoryScope);
     state(): Promise<ContractState>;
+    guidance(): Promise<string>;
     delivery(): Promise<Delivery | null>;
     amend(input: AmendInput): Promise<AmendResult>;
     deliver(input?: DeliverInput): Promise<MutationResult<Delivery>>;
@@ -141,5 +117,3 @@ export declare function keiyakuOf(input: KeiyakuOfInput): Keiyaku;
 export declare function listKeiyaku(input: ContractListInput): Promise<ContractBoard>;
 export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
 export declare function bindKeiyaku(input: BindInput): Promise<BindResult>;
-/** Internal package composition read used by Kanshi; not a package-root export. */
-export declare function taskHoldersForRepo(repo: Repo): readonly TaskHolder[];

package/build/src/library/contract.js

@@ -2,46 +2,26 @@ import { documentDiff } from "../markdown/diff.js";
 import { applyAmendDocument } from "../body/amend.js";
 import { decodeArcDocument } from "../body/arc.js";
 import { decodeContractDocument } from "../body/decode.js";
-import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalNonblank, requireInput, requireMarkdown, } from "./input.js";
+import { renderContractGuidance, } from "../contract-worktree.js";
+import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
 import { observeRegion } from "./region.js";
-import { worktreeHooksOption, } from "./configuration.js";
+import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { abandonOperation, amendOperation, arcOperation, auditOperation, bindOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, readStateOperation, reconcileOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
-import { settle } from "../settlement/settle.js";
-import { claimTaskHolder, readTaskHolders, releaseTaskHolder } from "../settlement/holder.js";
+import { abandonOperation, amendOperation, arcOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
 import { parseTaskId } from "../task/identity.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
-export { gatesFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
-export class KeiyakuRefused extends Error {
-    refusal;
-    constructor(refusal) {
-        super(`Keiyaku refused: ${refusal.kind}`);
-        this.refusal = refusal;
-        this.name = "KeiyakuRefused";
-    }
-    get code() {
-        return this.refusal.kind;
-    }
-}
-export class KeiyakuRetry extends Error {
-    reason;
-    constructor(reason) {
-        super(reason.kind === "publication-failed" ? reason.diagnostic : `Keiyaku retry required: ${reason.kind}`);
-        this.reason = reason;
-        this.name = "KeiyakuRetry";
-    }
-    get code() {
-        return this.reason.kind;
-    }
-}
-function requireAccepted(result) {
-    if (result.kind === "refused")
-        throw new KeiyakuRefused(result.refusal);
-    if (result.kind === "retry")
-        throw new KeiyakuRetry(result.reason);
-    return result;
-}
+import { auditContract } from "./audit.js";
+import { Delivery, deliveryHandle } from "./delivery.js";
+import { completeHolderMutation, completeMutation, } from "./mutation.js";
+import { completeReconcile } from "./reconcile.js";
+import { admitBindWithAppointment } from "./bind.js";
+import { KeiyakuRefused, requireAccepted } from "./refusal.js";
+export { KeiyakuRefused, KeiyakuRetry, } from "./refusal.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
+export { Delivery };
 function taskOption(value) {
     if (value === undefined)
         return undefined;
@@ -55,38 +35,9 @@ function taskOption(value) {
     }
     return value;
 }
-async function mutationResult(scope, id, accepted, value, hooks) {
-    const reconciled = await reconcileOperation({ scope, contractId: id, hooks, retryHooks: false });
-    const settlement = await settle({ repository: scope, state: reconciled.state, effects: reconciled.report.effects });
-    return {
-        facts: accepted.facts,
-        head: accepted.head,
-        value: value(accepted.value),
-        effects: reconciled.report.effects,
-        lags: reconciled.report.lag,
-        settlement,
-    };
+function completion(scope, channel, id, value, hooks) {
+    return { scope, channel, contractId: id, value, hooks };
 }
-class DeliveryHandle {
-    snapshotId;
-    changeId;
-    expectedPredecessor;
-    readDiff;
-    constructor(snapshotId, changeId, expectedPredecessor, readDiff, outcomes = {}) {
-        this.snapshotId = snapshotId;
-        this.changeId = changeId;
-        this.expectedPredecessor = expectedPredecessor;
-        this.readDiff = readDiff;
-        Object.assign(this, outcomes);
-    }
-    diff() {
-        return this.readDiff();
-    }
-}
-function handleType(prototype, hasInstance) {
-    return Object.freeze({ prototype, [Symbol.hasInstance]: hasInstance });
-}
-export const Delivery = handleType(DeliveryHandle.prototype, (value) => value instanceof DeliveryHandle);
 export class KeiyakuHandle {
     id;
     scope;
@@ -96,10 +47,26 @@ export class KeiyakuHandle {
         KEIYAKU_SEATS.set(this, { id, scope });
     }
     async state() {
-        return stateOperation({ scope: this.scope, contractId: this.id });
+        return withGitDecodeChannel(this.scope, (channel) => stateOperation({
+            scope: this.scope,
+            channel,
+            contractId: this.id,
+        }));
+    }
+    async guidance() {
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
+            if (observed.kind === "missing")
+                throw new KeiyakuRefused({ kind: "contract-missing", contractId: this.id });
+            return renderContractGuidance(await stateOperation({ scope: this.scope, channel, contractId: this.id }));
+        });
     }
     async delivery() {
-        const delivery = deliveryOperation({ scope: this.scope, contractId: this.id });
+        const delivery = await withGitDecodeChannel(this.scope, (channel) => deliveryOperation({
+            scope: this.scope,
+            channel,
+            contractId: this.id,
+        }));
         return delivery === null
             ? null
             : this.deliveryHandle(delivery);
@@ -113,53 +80,57 @@ export class KeiyakuHandle {
         const prerequisites = values.after === undefined
             ? undefined
             : normalizedList(values.after, "after", contractId);
-        const current = readStateOperation({ scope: this.scope, contractId: this.id });
-        let document;
-        let terms;
-        let verification;
-        if (current !== null) {
-            const before = current.terms.document.bytes;
-            const currentDocument = decodeContractDocument(before);
-            document = decodeContractDocument(applyAmendDocument(markdown, currentDocument));
-            terms = contractTerms(document, gates ?? current.terms.gates, prerequisites ?? current.terms.after);
-            verification = documentDerivation(document, terms.gates, this.id).verification;
-        }
-        const accepted = requireAccepted(amendOperation({
-            scope: this.scope,
-            contractId: this.id,
-            ...actor,
-            ...(current === null || terms === undefined || verification === undefined
-                ? {}
-                : { amendment: { source: current.terms, terms, verification } }),
-        }));
-        if (document === undefined || current === null) {
-            throw new Error("accepted amendment is missing its document derivation");
-        }
-        const before = current.terms.document.bytes;
-        const after = document.document.bytes;
-        return {
-            ...await mutationResult(this.scope, this.id, accepted, () => undefined, hooks),
-            documentDiff: documentDiff("before", "after", before, after),
-            ...observeRegion(this.scope, this.id, document.region),
-        };
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await amendOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actor,
+                deriveAmendment: (source) => {
+                    const document = decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
+                    const terms = contractTerms(document, gates ?? source.gates, prerequisites ?? source.after);
+                    return {
+                        terms,
+                        verification: documentDerivation(document, terms.gates, this.id).verification,
+                    };
+                },
+            }));
+            const document = decodeContractDocument(accepted.value.terms.document.bytes);
+            return {
+                ...await completeMutation({
+                    ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                    accepted,
+                }),
+                documentDiff: documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes),
+                ...await observeRegion(this.scope, channel, this.id, document.region),
+            };
+        });
     }
     async deliver(input) {
         const values = input === undefined ? undefined : requireInput(input, "deliver input");
         const hooks = worktreeHooksOption(values?.hooks);
         const message = optionalNonblank(values?.message, "deliver message");
+        const requireBranchesToBeUpToDate = optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false;
+        const includeDirty = optionalBoolean(values?.includeDirty, "includeDirty") ?? false;
         const actor = actorOption(values?.actor);
-        const state = readStateOperation({ scope: this.scope, contractId: this.id });
-        const derivation = state === null
-            ? undefined
-            : documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
-        const accepted = requireAccepted(await deliverOperation({
-            scope: this.scope,
-            contractId: this.id,
-            ...(derivation === undefined ? {} : { derivation }),
-            ...actor,
-            ...(message === undefined ? {} : { message }),
-        }));
-        return mutationResult(this.scope, this.id, accepted, (delivery) => this.deliveryHandle(delivery), hooks);
+        const signal = optionalSignal(values?.signal);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await deliverOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+                ...actor,
+                ...(message === undefined ? {} : { message }),
+                requireBranchesToBeUpToDate,
+                includeDirty,
+                ...(signal === undefined ? {} : { signal }),
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, (delivery) => this.deliveryHandle(delivery), hooks),
+                accepted,
+            });
+        });
     }
     async review(input) {
         const values = requireInput(input, "review input");
@@ -169,73 +140,82 @@ export class KeiyakuHandle {
             throw new TypeError("verdict must be satisfied or unsatisfied");
         }
         const summary = optionalNonblank(values.summary, "review summary");
-        const accepted = requireAccepted(reviewOperation({
-            scope: this.scope,
-            contractId: this.id,
-            verdict,
-            ...(summary === undefined ? {} : { summary }),
-            ...actorOption(values.actor),
-        }));
-        return mutationResult(this.scope, this.id, accepted, (value) => value, hooks);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await reviewOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                verdict,
+                ...(summary === undefined ? {} : { summary }),
+                ...actorOption(values.actor),
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, (value) => value, hooks),
+                accepted,
+            });
+        });
     }
     async abandon(input) {
         const values = input === undefined ? undefined : requireInput(input, "abandon input");
         const hooks = worktreeHooksOption(values?.hooks);
         const note = optionalNonblank(values?.note, "abandon note");
-        const accepted = requireAccepted(abandonOperation({
-            scope: this.scope,
-            contractId: this.id,
-            ...actorOption(values?.actor),
-            ...(note === undefined ? {} : { note }),
-            decorateOffer: ({ repository, observation, contractId: owner }) => {
-                const companion = releaseTaskHolder(repository, observation.admission.snapshot, owner);
-                return companion === null ? [] : [companion];
-            },
-        }));
-        return mutationResult(this.scope, this.id, accepted, () => undefined, hooks);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const admission = await releaseTaskHolderWithFence(this.scope, channel, this.id, () => abandonOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actorOption(values?.actor),
+                ...(note === undefined ? {} : { note }),
+                observationSelection: taskHolderObservationSelection(),
+                decorateOffer: async ({ observation, contractId: owner }) => {
+                    const companion = await releaseTaskHolder(channel, observation, owner);
+                    return companion === null ? [] : [companion];
+                },
+            }));
+            return completeHolderMutation({
+                completion: completion(this.scope, channel, this.id, () => undefined, hooks),
+                admission,
+                requireAccepted,
+            });
+        });
     }
     async arc(input) {
         const values = requireInput(input, "arc input");
         const hooks = worktreeHooksOption(values.hooks);
         const chapter = decodeArcDocument(requireMarkdown(values.markdown));
-        const accepted = requireAccepted(arcOperation({
-            scope: this.scope,
-            contractId: this.id,
-            ...actorOption(values.actor),
-            chapter,
-        }));
-        return mutationResult(this.scope, this.id, accepted, () => undefined, hooks);
+        return withGitDecodeChannel(this.scope, async (channel) => {
+            const accepted = requireAccepted(await arcOperation({
+                scope: this.scope,
+                channel,
+                contractId: this.id,
+                ...actorOption(values.actor),
+                chapter,
+            }));
+            return completeMutation({
+                ...completion(this.scope, channel, this.id, () => undefined, hooks),
+                accepted,
+            });
+        });
     }
     async audit(input) {
-        const values = input === undefined ? undefined : requireInput(input, "audit input");
-        const hooks = worktreeHooksOption(values?.hooks);
-        const actor = actorOption(values?.actor);
-        const state = readStateOperation({ scope: this.scope, contractId: this.id });
-        const derivation = state === null
-            ? undefined
-            : documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
-        const accepted = requireAccepted(await auditOperation({
+        return auditContract({
             scope: this.scope,
             contractId: this.id,
-            ...(derivation === undefined ? {} : { derivation }),
-            ...actor,
-        }));
-        return mutationResult(this.scope, this.id, accepted, (report) => report, hooks);
+            ...(input === undefined ? {} : { input }),
+        });
     }
     async reconcile(input) {
         const options = reconcileInput(input);
-        const reconciled = await reconcileOperation({ scope: this.scope, contractId: this.id, ...options });
-        return {
-            ...reconciled.report,
-            settlement: await settle({ repository: this.scope, state: reconciled.state, effects: reconciled.report.effects }),
-        };
+        return withGitDecodeChannel(this.scope, (channel) => completeReconcile({
+            scope: this.scope, channel, contractId: this.id, ...options,
+        }));
     }
     deliveryHandle(delivery) {
-        return new DeliveryHandle(delivery.snapshotId, delivery.changeId, delivery.expectedPredecessor, () => deliveryDiffOperation({
+        return deliveryHandle(delivery, () => deliveryDiffOperation({
             scope: this.scope,
-            expectedPredecessor: delivery.expectedPredecessor,
-            snapshotId: delivery.snapshotId,
-        }), delivery);
+            integrationPredecessor: delivery.integration.predecessor,
+            integrationSnapshot: delivery.integration.snapshot,
+        }));
     }
 }
 const KEIYAKU_SEATS = new WeakMap();
@@ -260,7 +240,8 @@ export async function listKeiyaku(input) {
     for (const key of Object.keys(values))
         if (key !== "repo")
             throw new TypeError(`Keiyaku.list input has unknown field: ${key}`);
-    return contractsOperation({ scope: scopeForRepo(values.repo) });
+    const scope = scopeForRepo(values.repo);
+    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
 }
 export async function observeKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.observe input");
@@ -277,7 +258,7 @@ export async function observeKeiyaku(input) {
     catch (error) {
         throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
     }
-    return contractObservationOperation({ scope, contractId: id });
+    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
 }
 export async function bindKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.bind input");
@@ -294,32 +275,37 @@ export async function bindKeiyaku(input) {
         throw new TypeError("target must be a string");
     const actor = actorOption(values.actor);
     const terms = contractTerms(document, normalizedGates(values.gates), normalizedList(values.after, "after", contractId));
-    const admitted = bindOperation({
-        scope,
-        title: document.title,
-        terms,
-        verification: documentDerivation(document, terms.gates).verification,
-        workspace,
-        ...(target === undefined ? {} : { target }),
-        ...(task === undefined ? {} : {
-            decorateOffer: ({ contractId: owner }) => [claimTaskHolder(task, owner)],
-        }),
-        ...actor,
+    return withGitDecodeChannel(scope, async (channel) => {
+        const admitCandidate = () => admitBindWithAppointment({
+            scope,
+            channel,
+            title: document.title,
+            terms,
+            verification: documentDerivation(document, terms.gates).verification,
+            workspace,
+            ...(target === undefined ? {} : { target }),
+            ...(task === undefined ? {} : { task }),
+            ...actor,
+        });
+        const admission = task === undefined ? null : await claimTaskHolderWithFence(scope, task, admitCandidate);
+        const accepted = requireAccepted(admission === null ? await admitCandidate() : admission.result);
+        const id = accepted.value.contractId;
+        const toHandle = ({ contractId: contract }) => new KeiyakuHandle(contract, scope);
+        const result = admission === null
+            ? await completeMutation({ ...completion(scope, channel, id, toHandle, hooks), accepted })
+            : await completeHolderMutation({
+                completion: completion(scope, channel, id, toHandle, hooks),
+                admission,
+                requireAccepted,
+            });
+        return {
+            facts: result.facts,
+            head: result.head,
+            keiyaku: result.value,
+            effects: result.effects,
+            lags: result.lags,
+            settlement: result.settlement,
+            ...await observeRegion(scope, channel, id, document.region),
+        };
     });
-    const accepted = requireAccepted(admitted);
-    const id = accepted.value.contractId;
-    const result = await mutationResult(scope, id, accepted, ({ contractId: contract }) => new KeiyakuHandle(contract, scope), hooks);
-    return {
-        facts: result.facts,
-        head: result.head,
-        keiyaku: result.value,
-        effects: result.effects,
-        lags: result.lags,
-        settlement: result.settlement,
-        ...observeRegion(scope, id, document.region),
-    };
-}
-/** Internal package composition read used by Kanshi; not a package-root export. */
-export function taskHoldersForRepo(repo) {
-    return readTaskHolders(scopeForRepo(repo));
 }