@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -0,0 +1,24 @@
+import type { SnapshotId } from "../core/facts/types.js";
+import type { DeliverValue } from "../protocol/operations.js";
+declare class DeliveryHandle {
+    private readonly readDiff;
+    readonly verification?: DeliverValue["verification"];
+    readonly verificationReuse?: DeliverValue["verificationReuse"];
+    readonly placement?: DeliverValue["placement"];
+    readonly cleanup?: DeliverValue["cleanup"];
+    readonly leak?: DeliverValue["leak"];
+    readonly tenderSnapshot: SnapshotId;
+    readonly integration: DeliverValue["integration"];
+    readonly method: DeliverValue["method"];
+    readonly policy: DeliverValue["policy"];
+    constructor(identity: Pick<DeliverValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliverValue, "verification" | "verificationReuse" | "placement" | "cleanup" | "leak">>);
+    diff(): Promise<string | null>;
+}
+export type Delivery = DeliveryHandle;
+type HandleType<T extends object> = Readonly<{
+    prototype: T;
+    [Symbol.hasInstance](value: unknown): boolean;
+}>;
+export declare const Delivery: HandleType<DeliveryHandle>;
+export declare function deliveryHandle(delivery: DeliverValue, readDiff: () => Promise<string | null>): Delivery;
+export {};

package/build/src/library/delivery.js

@@ -0,0 +1,21 @@
+class DeliveryHandle {
+    readDiff;
+    constructor(identity, readDiff, outcomes = {}) {
+        this.readDiff = readDiff;
+        this.tenderSnapshot = identity.tenderSnapshot;
+        this.integration = identity.integration;
+        this.method = identity.method;
+        this.policy = identity.policy;
+        Object.assign(this, outcomes);
+    }
+    diff() {
+        return this.readDiff();
+    }
+}
+export const Delivery = Object.freeze({
+    prototype: DeliveryHandle.prototype,
+    [Symbol.hasInstance]: (value) => value instanceof DeliveryHandle,
+});
+export function deliveryHandle(delivery, readDiff) {
+    return new DeliveryHandle(delivery, readDiff, delivery);
+}

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

@@ -0,0 +1,65 @@
+import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
+import type { ContractId } from "../core/facts/types.js";
+import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
+export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
+    completion?: "any" | "all";
+    timeoutMs?: number;
+}>;
+export type AkumaWaitResult = Readonly<{
+    completion: "any" | "all";
+    statuses: readonly AkumaStatusView[];
+}>;
+export type AkumaStatusView = Readonly<{
+    status: AkumaStatus;
+    contractId?: ContractId;
+}>;
+export type AkumaKillResult = Readonly<{
+    results: readonly Readonly<{
+        id: AkumaStatus["id"];
+        evidence: KillEvidence;
+        observation: AkumaStatusView;
+    }>[];
+}>;
+export type AkumaTellInput = AkumaAddressInput & Readonly<{
+    body: string;
+}>;
+export type AkumaTellResult = Readonly<{
+    akuma: AkumaStatus["id"];
+    tell: TellResult;
+    observation: AkumaStatusView;
+}>;
+export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
+    body: string;
+}>;
+export type AkumaInterruptResult = Readonly<{
+    id: AkumaStatus["id"];
+    receipt: InterruptReceipt;
+    observation: AkumaStatusView;
+}>;
+export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
+    before?: number;
+    since?: number;
+    limit?: number;
+    last?: boolean;
+}>;
+export type AkumaHistoryResult = Readonly<{
+    kind: "history";
+    id: AkumaStatus["id"];
+    history: ActivityHistory;
+    contractId?: ContractId;
+}> | Readonly<{
+    kind: "last";
+    id: AkumaStatus["id"];
+    answer: string;
+    contractId?: ContractId;
+}> | Readonly<{
+    kind: "no-answer";
+    id: AkumaStatus["id"];
+    contractId?: ContractId;
+}>;
+export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaStatusView>;
+export declare function waitAkuma(input: AkumaWaitInput): Promise<AkumaWaitResult>;
+export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKillResult>;
+export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
+export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
+export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;

package/build/src/library/fleet.js

@@ -0,0 +1,153 @@
+import { Akuma, } from "../akuma/index.js";
+import { readActionFeedbackStatus, readBudgetedStatus } from "../akuma/akuma.js";
+import { readDispatch } from "../dispatch/index.js";
+import { addressAkuma, addressAkumaSet } from "./address.js";
+import { requireInput } from "./input.js";
+import { scopeForRepo } from "./repo.js";
+function source(path, settings) {
+    return Akuma.of(path, settings);
+}
+async function contractFor(repo, id) {
+    const dispatch = repo === undefined ? null : await readDispatch(scopeForRepo(repo), id);
+    return dispatch?.contractId;
+}
+async function statusView(status, repo) {
+    const contractId = await contractFor(repo, status.id);
+    return contractId === undefined ? { status } : { status, contractId };
+}
+function timeout(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new TypeError("timeoutMs must be a nonnegative finite number");
+    }
+    return value;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+const SHARED_ORDINARY_BUDGET = 30;
+async function observeWaitStatuses(path, ids, settings) {
+    if (ids.length <= 1) {
+        return await Promise.all(ids.map(async (id) => await source(path, settings).of({ id }).status()));
+    }
+    let remaining = SHARED_ORDINARY_BUDGET;
+    const statuses = [];
+    for (const id of ids) {
+        const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
+        statuses.push(observed.status);
+        remaining -= observed.ordinarySelected;
+    }
+    return statuses;
+}
+function directAddress(values) {
+    return {
+        path: values.path,
+        akuma: values.akuma,
+        ...(values.settings === undefined ? {} : { settings: values.settings }),
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    };
+}
+function setAddress(values) {
+    return {
+        path: values.path,
+        akuma: values.akuma,
+        ...(values.settings === undefined ? {} : { settings: values.settings }),
+        ...(values.repo === undefined ? {} : { repo: values.repo }),
+    };
+}
+export async function statusAkuma(input) {
+    const addressed = await addressAkuma(input);
+    return await statusView(await source(addressed.path, addressed.settings).of({ id: addressed.id }).status(), input.repo);
+}
+export async function waitAkuma(input) {
+    const values = requireInput(input, "Keiyaku.wait input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "repo", "completion", "timeoutMs"].includes(key)) {
+            throw new TypeError(`Keiyaku.wait input has unknown field: ${key}`);
+        }
+    }
+    const addressed = await addressAkumaSet(setAddress(values));
+    const completion = values.completion;
+    if (addressed.ids.length > 1 && completion !== "any" && completion !== "all") {
+        throw new TypeError("completion must be any or all when waiting for multiple Akuma");
+    }
+    if (completion !== undefined && completion !== "any" && completion !== "all")
+        throw new TypeError("completion must be any or all");
+    const selected = completion ?? "all";
+    const timeoutMs = timeout(values.timeoutMs);
+    const deadline = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+    for (;;) {
+        const statuses = await observeWaitStatuses(addressed.path, addressed.ids, addressed.settings);
+        const settled = statuses.map((status) => status.life !== "running");
+        if ((selected === "any" ? settled.some(Boolean) : settled.every(Boolean))
+            || (deadline !== undefined && performance.now() >= deadline)) {
+            return { completion: selected, statuses: await Promise.all(statuses.map(async (status) => await statusView(status, values.repo))) };
+        }
+        await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())));
+    }
+}
+export async function killAkuma(input) {
+    const addressed = await addressAkumaSet(input);
+    const handles = addressed.ids.map((id) => source(addressed.path, addressed.settings).of({ id }));
+    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill()));
+    const observations = await Promise.all(addressed.ids.map(async (id) => await statusView(await readActionFeedbackStatus(addressed.path, id), input.repo)));
+    return {
+        results: addressed.ids.map((id, index) => ({
+            id,
+            evidence: evidence[index],
+            observation: observations[index],
+        })),
+    };
+}
+export async function tellAkuma(input) {
+    const values = requireInput(input, "Keiyaku.tell input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+            throw new TypeError(`Keiyaku.tell input has unknown field: ${key}`);
+    }
+    if (typeof values.body !== "string")
+        throw new TypeError("body must be a string");
+    const addressed = await addressAkuma(directAddress(values));
+    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
+    const tell = await handle.tell(values.body);
+    return { akuma: addressed.id, tell, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+}
+export async function interruptAkuma(input) {
+    const values = requireInput(input, "Keiyaku.interrupt input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "body", "repo"].includes(key))
+            throw new TypeError(`Keiyaku.interrupt input has unknown field: ${key}`);
+    }
+    if (typeof values.body !== "string")
+        throw new TypeError("body must be a string");
+    const addressed = await addressAkuma(directAddress(values));
+    const receipt = await source(addressed.path, addressed.settings).of({ id: addressed.id }).interrupt(values.body);
+    return { id: addressed.id, receipt, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+}
+export async function historyAkuma(input) {
+    const values = requireInput(input, "Keiyaku.history input");
+    for (const key of Object.keys(values)) {
+        if (!["path", "akuma", "settings", "before", "since", "limit", "last", "repo"].includes(key)) {
+            throw new TypeError(`Keiyaku.history input has unknown field: ${key}`);
+        }
+    }
+    if (values.last !== undefined && typeof values.last !== "boolean")
+        throw new TypeError("last must be a boolean");
+    const addressed = await addressAkuma(directAddress(values));
+    const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
+    if (values.last === true) {
+        const answer = await handle.lastAnswer();
+        const contractId = await contractFor(values.repo, addressed.id);
+        return answer.kind === "answer"
+            ? { kind: "last", id: addressed.id, answer: answer.answer, ...(contractId === undefined ? {} : { contractId }) }
+            : { kind: "no-answer", id: addressed.id, ...(contractId === undefined ? {} : { contractId }) };
+    }
+    const history = await handle.history({
+        ...(values.before === undefined ? {} : { before: values.before }),
+        ...(values.since === undefined ? {} : { since: values.since }),
+        ...(values.limit === undefined ? {} : { limit: values.limit }),
+    });
+    const contractId = await contractFor(values.repo, addressed.id);
+    return { kind: "history", id: addressed.id, history, ...(contractId === undefined ? {} : { contractId }) };
+}

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

@@ -6,7 +6,10 @@ export declare function actorOption(actor: unknown): Readonly<{
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+export declare function rejectUnknownFields(values: Record<string, unknown>, allowed: readonly string[], label: string): void;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
+export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;
+export declare function optionalSignal(value: unknown): AbortSignal | undefined;
 export declare function normalizedList<T>(values: unknown, label: string, brand: (value: string) => T): readonly T[];
 export declare function normalizedGates(values: unknown): readonly Gate[];
 export declare function contractTerms(document: DecodedContractDocument, gates: readonly Gate[], after: readonly ContractId[]): ContractTerms;

package/build/src/library/input.js

@@ -22,6 +22,11 @@ export function requireInput(value, label) {
         throw new TypeError(`${label} must be an object`);
     return value;
 }
+export function rejectUnknownFields(values, allowed, label) {
+    for (const key of Object.keys(values))
+        if (!allowed.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
+}
 export function optionalNonblank(value, label) {
     if (value === undefined)
         return undefined;
@@ -30,6 +35,20 @@ export function optionalNonblank(value, label) {
     }
     return value;
 }
+export function optionalBoolean(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new TypeError(`${label} must be a boolean`);
+    return value;
+}
+export function optionalSignal(value) {
+    if (value === undefined)
+        return undefined;
+    if (!(value instanceof AbortSignal))
+        throw new TypeError("signal must be an AbortSignal");
+    return value;
+}
 export function normalizedList(values, label, brand) {
     if (values === undefined)
         return [];

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

@@ -1,12 +1,16 @@
 import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, type Keiyaku as KeiyakuType } from "./contract.js";
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TimelineEntry, TaskId, TopologyEffect, VerificationStop, } from "./contract.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, } from "./configuration.js";
+export { worktreeHooksFrom } from "../git/hooks.js";
+export { AkumaWorldScopeError } from "./address.js";
+export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, DeliverInput, Fact, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId, } from "../core/facts/types.js";
-export type { Gate, GatesFromInput, HookCommand, WorktreeHooks, WorktreeHooksFromInput, } from "./configuration.js";
+export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";
 export type { ReconcileInput, RepoAtInput, RepoReconcileReport, } from "./repo.js";
 export type { SettlementAction, SettlementLag, SettlementReport, } from "../settlement/settle.js";
@@ -14,7 +18,11 @@ export type { AliasStage, AkumaStatus, CallObservation, CallInput, CallResult, D
 export type { AliasBinding } from "../alias/index.js";
 export type { Dispatch, DispatchFailure } from "../dispatch/index.js";
 export type { AkumaAlias } from "../identity/selector.js";
+export type { AkumaGlob } from "../identity/selector.js";
 export type { AkuId } from "../akuma/identity.js";
+export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
+export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
+export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaStatusView, AkumaTellInput, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
 export type Keiyaku = KeiyakuType;
 export declare const Keiyaku: Readonly<{
     prototype: KeiyakuHandle;
@@ -22,7 +30,14 @@ export declare const Keiyaku: Readonly<{
     bind: typeof bindKeiyaku;
     call: typeof callKeiyaku;
     fork: typeof forkKeiyaku;
+    history: typeof historyAkuma;
+    interrupt: typeof interruptAkuma;
+    kill: typeof killAkuma;
+    ls: typeof listCatalog;
     list: typeof listKeiyaku;
     observe: typeof observeKeiyaku;
     of: typeof keiyakuOf;
+    status: typeof statusAkuma;
+    tell: typeof tellAkuma;
+    wait: typeof waitAkuma;
 }>;

package/build/src/library/keiyaku.js

@@ -1,16 +1,27 @@
 import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, } from "./contract.js";
 import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
+import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma, } from "./fleet.js";
+import { listCatalog } from "./catalog.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, } from "./configuration.js";
+export { worktreeHooksFrom } from "../git/hooks.js";
+export { AkumaWorldScopeError } from "./address.js";
 export const Keiyaku = Object.freeze({
     prototype: KeiyakuHandle.prototype,
     [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
     bind: bindKeiyaku,
     call: callKeiyaku,
     fork: forkKeiyaku,
+    history: historyAkuma,
+    interrupt: interruptAkuma,
+    kill: killAkuma,
+    ls: listCatalog,
     list: listKeiyaku,
     observe: observeKeiyaku,
     of: keiyakuOf,
+    status: statusAkuma,
+    tell: tellAkuma,
+    wait: waitAkuma,
 });

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

@@ -0,0 +1,39 @@
+import type { ContractHead, ContractId, JournalEntry } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import type { ReconcileReport, RepositoryScope } from "../protocol/operations.js";
+import type { IntentOutcome } from "../protocol/operations.js";
+import type { AcceptedObligations } from "../protocol/outcome.js";
+import { type SettlementReport } from "../settlement/settle.js";
+import type { TaskHolderAdmission } from "../settlement/holder.js";
+import type { WorktreeHooks } from "./configuration.js";
+import { type ReconcileCompletion } from "./reconcile.js";
+export type AcceptedIntent<Value> = Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Value;
+    physical?: ReconcileReport;
+} & AcceptedObligations>;
+export type MutationResult<Value> = Readonly<{
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Value;
+    effects: ReconcileCompletion["effects"];
+    lags: ReconcileCompletion["lag"];
+    settlement: SettlementReport;
+} & AcceptedObligations>;
+type Completion<Value, PublicValue> = Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    contractId: ContractId;
+    accepted: AcceptedIntent<Value>;
+    value: (result: Value) => PublicValue;
+    hooks: WorktreeHooks;
+}>;
+export declare function completeMutation<Value, PublicValue>(input: Completion<Value, PublicValue>): Promise<MutationResult<PublicValue>>;
+export declare function completeHolderMutation<Value, PublicValue, Refusal>(input: Readonly<{
+    completion: Omit<Completion<Value, PublicValue>, "accepted">;
+    admission: TaskHolderAdmission<IntentOutcome<Value, Refusal>>;
+    requireAccepted: (result: IntentOutcome<Value, Refusal>) => AcceptedIntent<Value>;
+}>): Promise<MutationResult<PublicValue>>;
+export {};

package/build/src/library/mutation.js

@@ -0,0 +1,37 @@
+import { deferredTaskHolderSettlement } from "../settlement/settle.js";
+import { completeReconcile } from "./reconcile.js";
+export async function completeMutation(input) {
+    const { scope, channel, contractId, accepted, value, hooks } = input;
+    const report = await completeReconcile({ scope, channel, contractId, hooks, retryHooks: false });
+    const obligations = {
+        ...(accepted.cleanup === undefined ? {} : { cleanup: accepted.cleanup }),
+        ...(accepted.leak === undefined ? {} : { leak: accepted.leak }),
+    };
+    return {
+        facts: accepted.facts,
+        head: accepted.head,
+        value: value(accepted.value),
+        effects: [...(accepted.physical?.effects ?? []), ...report.effects],
+        lags: [...(accepted.physical?.lag ?? []), ...report.lag],
+        settlement: report.settlement,
+        ...obligations,
+    };
+}
+export async function completeHolderMutation(input) {
+    const accepted = input.requireAccepted(input.admission.result);
+    const completed = await completeMutation({ ...input.completion, accepted });
+    if (input.admission.kind === "completed")
+        return completed;
+    const deferred = deferredTaskHolderSettlement({
+        contractId: input.completion.contractId,
+        taskId: input.admission.taskId,
+        diagnostic: input.admission.diagnostic,
+    });
+    return {
+        ...completed,
+        settlement: {
+            actions: completed.settlement.actions,
+            lags: [...completed.settlement.lags, ...deferred.lags],
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+import type { ContractId } from "../core/facts/types.js";
+import type { GitDecodeChannel } from "../git/read-observation.js";
+import { type ReconcileReport, type RepositoryScope } from "../protocol/operations.js";
+import { type SettlementReport } from "../settlement/settle.js";
+import type { WorktreeHooks } from "./configuration.js";
+import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
+export type ReconcileCompletion = Readonly<{
+    effects: readonly (ReconcileReport["effects"][number] | ContractFileEffect)[];
+    lag: readonly (ReconcileReport["lag"][number] | ContractFileLag)[];
+    settlement: SettlementReport;
+}>;
+export type RepoContractReconcileReport = ReconcileCompletion;
+export type RepoReconcileReport = Readonly<{
+    contracts: readonly Readonly<{
+        contractId: ContractId;
+        report: RepoContractReconcileReport;
+    }>[];
+}>;
+type ReconcileOptions = Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    hooks: WorktreeHooks;
+    retryHooks: boolean;
+}>;
+export declare function completeReconcile(input: ReconcileOptions & Readonly<{
+    contractId: ContractId;
+}>): Promise<ReconcileCompletion>;
+export declare function completeRepoReconcile(input: ReconcileOptions): Promise<RepoReconcileReport>;
+export {};