@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -57,9 +57,9 @@ export type AkumaHistoryResult = Readonly<{
     id: AkumaStatus["id"];
     contractId?: ContractId;
 }>;
-export declare function statusAkuma(input: AkumaAddressInput): AkumaStatusView;
+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): AkumaHistoryResult;
+export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;

package/build/src/library/fleet.js

@@ -1,5 +1,5 @@
 import { Akuma, } from "../akuma/index.js";
-import { readActionFeedbackStatus } from "../akuma/akuma.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";
@@ -7,11 +7,12 @@ import { scopeForRepo } from "./repo.js";
 function source(path, settings) {
     return Akuma.of(path, settings);
 }
-function contractFor(repo, id) {
-    return repo === undefined ? undefined : readDispatch(scopeForRepo(repo), id)?.contractId;
+async function contractFor(repo, id) {
+    const dispatch = repo === undefined ? null : await readDispatch(scopeForRepo(repo), id);
+    return dispatch?.contractId;
 }
-function statusView(status, repo) {
-    const contractId = contractFor(repo, status.id);
+async function statusView(status, repo) {
+    const contractId = await contractFor(repo, status.id);
     return contractId === undefined ? { status } : { status, contractId };
 }
 function timeout(value) {
@@ -25,55 +26,19 @@ function timeout(value) {
 function delay(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-const PLURAL_DETAIL_LIMIT = 32;
-function pinned(entry) {
-    return entry.kind === "row"
-        && ((entry.row.kind === "tool" && entry.row.state === "running")
-            || (entry.row.kind === "tell" && entry.row.state === "pending"));
-}
-function budgetStatus(status, allowance) {
-    const entries = [];
-    const ordinary = status.timeline.entries.filter((entry) => entry.kind === "row" && !pinned(entry));
-    const kept = new Set(allowance === 0 ? [] : ordinary.slice(-allowance));
-    const used = kept.size;
-    let hidden = 0;
-    let single;
-    const flush = () => {
-        if (hidden === 1 && single !== undefined)
-            entries.push(single);
-        else if (hidden > 0)
-            entries.push({ kind: "gap", count: hidden });
-        hidden = 0;
-        single = undefined;
-    };
-    for (const entry of status.timeline.entries) {
-        if (pinned(entry)) {
-            flush();
-            entries.push(entry);
-            continue;
-        }
-        if (entry.kind === "row" && kept.has(entry)) {
-            flush();
-            entries.push(entry);
-            continue;
-        }
-        const count = entry.kind === "gap" ? entry.count : 1;
-        if (hidden === 0 && count === 1 && entry.kind === "row")
-            single = entry;
-        else
-            single = undefined;
-        hidden += count;
+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()));
     }
-    flush();
-    return { status: { ...status, timeline: { ...status.timeline, entries } }, used };
-}
-function budgetPlural(statuses) {
-    let remaining = PLURAL_DETAIL_LIMIT;
-    return statuses.map((status) => {
-        const budgeted = budgetStatus(status, remaining);
-        remaining -= budgeted.used;
-        return budgeted.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 {
@@ -91,9 +56,9 @@ function setAddress(values) {
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
-export function statusAkuma(input) {
-    const addressed = addressAkuma(input);
-    return statusView(source(addressed.path, addressed.settings).of({ id: addressed.id }).status(), input.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");
@@ -111,15 +76,13 @@ export async function waitAkuma(input) {
         throw new TypeError("completion must be any or all");
     const selected = completion ?? "all";
     const timeoutMs = timeout(values.timeoutMs);
-    const handles = addressed.ids.map((id) => source(addressed.path, addressed.settings).of({ id }));
     const deadline = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
     for (;;) {
-        const statuses = handles.map((handle) => handle.status());
+        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)) {
-            const observed = statuses.length > 1 ? budgetPlural(statuses) : statuses;
-            return { completion: selected, statuses: observed.map((status) => statusView(status, values.repo)) };
+            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())));
     }
@@ -128,11 +91,12 @@ 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: statusView(readActionFeedbackStatus(addressed.path, id), input.repo),
+            observation: observations[index],
         })),
     };
 }
@@ -144,10 +108,10 @@ export async function tellAkuma(input) {
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
-    const addressed = addressAkuma(directAddress(values));
+    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: statusView(readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    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");
@@ -157,11 +121,11 @@ export async function interruptAkuma(input) {
     }
     if (typeof values.body !== "string")
         throw new TypeError("body must be a string");
-    const addressed = addressAkuma(directAddress(values));
+    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: statusView(readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
+    return { id: addressed.id, receipt, observation: await statusView(await readActionFeedbackStatus(addressed.path, addressed.id), values.repo) };
 }
-export function historyAkuma(input) {
+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)) {
@@ -170,20 +134,20 @@ export function historyAkuma(input) {
     }
     if (values.last !== undefined && typeof values.last !== "boolean")
         throw new TypeError("last must be a boolean");
-    const addressed = addressAkuma(directAddress(values));
+    const addressed = await addressAkuma(directAddress(values));
     const handle = source(addressed.path, addressed.settings).of({ id: addressed.id });
     if (values.last === true) {
-        const answer = handle.lastAnswer();
-        const contractId = contractFor(values.repo, addressed.id);
+        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 = handle.history({
+    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 = contractFor(values.repo, addressed.id);
+    const contractId = await contractFor(values.repo, addressed.id);
     return { kind: "history", id: addressed.id, history, ...(contractId === undefined ? {} : { contractId }) };
 }

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

@@ -7,7 +7,8 @@ export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, } from "./configuration.js";
 export { worktreeHooksFrom } from "../git/hooks.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 { 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, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
 export type { RegionOverlap } from "./region.js";
@@ -20,7 +21,7 @@ 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, DirectAkumaSelector, SetAkumaSelector, } from "./address.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<{

package/build/src/library/keiyaku.js

@@ -7,6 +7,7 @@ export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.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,

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

@@ -1,26 +1,27 @@
 import type { ContractHead, ContractId, JournalEntry } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { type ReconcileReport, type RepositoryScope } from "../protocol/operations.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 ContractFileEffect, type ContractFileLag } from "../contract-worktree.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: readonly (ReconcileReport["effects"][number] | ContractFileEffect)[];
-    lags: readonly (ReconcileReport["lag"][number] | ContractFileLag)[];
+    effects: ReconcileCompletion["effects"];
+    lags: ReconcileCompletion["lag"];
     settlement: SettlementReport;
-}>;
+} & AcceptedObligations>;
 type Completion<Value, PublicValue> = Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;

package/build/src/library/mutation.js

@@ -1,39 +1,37 @@
-import { reconcileOperation } from "../protocol/operations.js";
-import { deferredTaskHolderSettlement, settle } from "../settlement/settle.js";
-import { projectContractWorktree } from "../contract-worktree.js";
+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 retained = await reconcileOperation({ scope, channel, contractId, hooks, retryHooks: false, retainTerminalWorktree: true });
-    const projection = projectContractWorktree(scope, retained.state);
-    const settlement = await settle({ repository: scope, channel, state: retained.state, effects: retained.report.effects });
-    const deferRemoval = retained.state !== null && retained.state.terminal !== null
-        && retained.state.coordinates.workspace === "worktree";
-    const cleanup = deferRemoval
-        ? await reconcileOperation({ scope, channel, contractId, hooks, retryHooks: false })
-        : null;
+    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 ?? []), ...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
-        lags: [...(accepted.physical?.lag ?? []), ...retained.report.lag, ...projection.lag, ...(cleanup?.report.lag ?? [])],
-        settlement,
+        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 completeMutation({ ...input.completion, accepted });
+        return completed;
+    const deferred = deferredTaskHolderSettlement({
+        contractId: input.completion.contractId,
+        taskId: input.admission.taskId,
+        diagnostic: input.admission.diagnostic,
+    });
     return {
-        facts: accepted.facts,
-        head: accepted.head,
-        value: input.completion.value(accepted.value),
-        effects: [...(accepted.physical?.effects ?? [])],
-        lags: [...(accepted.physical?.lag ?? [])],
-        settlement: deferredTaskHolderSettlement({
-            contractId: input.completion.contractId,
-            taskId: input.admission.taskId,
-            diagnostic: input.admission.diagnostic,
-        }),
+        ...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 {};

package/build/src/library/reconcile.js

@@ -0,0 +1,179 @@
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { reconcileAllOperation, reconcileObservationFailure, reconcileOperation, stateOperation, worldContractStates, } from "../protocol/operations.js";
+import { settle, settleAll } from "../settlement/settle.js";
+import { projectContractWorktree, } from "../contract-worktree.js";
+import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
+function registerLag(scope, error) {
+    return {
+        kind: "contract-file-failed",
+        worktree: scope.primaryWorktree,
+        path: placeRegisterPath(scope),
+        diagnostic: error instanceof Error ? error.message : String(error),
+    };
+}
+function emptySettlement() {
+    return { actions: [], lags: [] };
+}
+function isManagedWorktree(state) {
+    return state.coordinates.workspace === "worktree";
+}
+function isManagedTerminal(state) {
+    return state !== null && isManagedWorktree(state) && state.terminal !== null;
+}
+function appointableManagedContracts(states) {
+    return states
+        .filter((state) => isManagedWorktree(state) && state.terminal === null)
+        .map((state) => state.id);
+}
+async function appointPlaces(scope, states) {
+    return await appointManagedWorktrees(scope, appointableManagedContracts(states));
+}
+function releaseEligible(state, cleanup, appointed) {
+    return cleanup !== undefined
+        && cleanup.lag.length === 0
+        && isManagedTerminal(state)
+        && appointed;
+}
+async function releaseAppointments(scope, contracts) {
+    try {
+        await releaseManagedWorktrees(scope, contracts);
+        return undefined;
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return registerLag(scope, error);
+    }
+}
+async function observeState(scope, channel, contractId) {
+    try {
+        return { state: await stateOperation({ scope, channel, contractId }) };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { failed: reconcileObservationFailure(error) };
+    }
+}
+async function appointForContract(scope, state) {
+    if (!isManagedWorktree(state))
+        return {};
+    try {
+        const register = await appointPlaces(scope, [state]);
+        const place = register.byContract.get(state.id)?.place;
+        if (place === undefined) {
+            if (state.terminal !== null)
+                return { register };
+            throw new Error(`Place appointment was not recorded: ${state.id}`);
+        }
+        return { place, register };
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        return { lag: registerLag(scope, error) };
+    }
+}
+export async function completeReconcile(input) {
+    const observed = await observeState(input.scope, input.channel, input.contractId);
+    if ("failed" in observed) {
+        return { effects: observed.failed.effects, lag: observed.failed.lag, settlement: emptySettlement() };
+    }
+    const appointment = await appointForContract(input.scope, observed.state);
+    if ("lag" in appointment) {
+        return { effects: [], lag: [appointment.lag], settlement: emptySettlement() };
+    }
+    const appointed = appointment.place === undefined ? {} : { place: appointment.place };
+    const retained = await reconcileOperation({
+        ...input,
+        retainTerminalWorktree: true,
+        ...appointed,
+    });
+    const projection = await projectContractWorktree(input.scope, retained.state, appointment.register);
+    const settlement = await settle({
+        repository: input.scope,
+        channel: input.channel,
+        state: retained.state,
+        effects: retained.report.effects,
+    });
+    const cleanup = isManagedTerminal(retained.state)
+        ? await reconcileOperation({ ...input, ...appointed })
+        : null;
+    const release = releaseEligible(retained.state, cleanup?.report, appointment.place !== undefined)
+        ? await releaseAppointments(input.scope, [input.contractId])
+        : undefined;
+    return {
+        effects: [...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
+        lag: [...retained.report.lag, ...projection.lag, ...(cleanup?.report.lag ?? []), ...(release === undefined ? [] : [release])],
+        settlement,
+    };
+}
+function attachReleaseLag(contracts, released, lag) {
+    const affected = new Set(released);
+    return {
+        contracts: contracts.map((contract) => affected.has(contract.contractId)
+            ? { ...contract, report: { ...contract.report, lag: [...contract.report.lag, lag] } }
+            : contract),
+    };
+}
+export async function completeRepoReconcile(input) {
+    const states = await worldContractStates(input);
+    let appointed;
+    try {
+        appointed = await appointPlaces(input.scope, states);
+    }
+    catch (error) {
+        if (error instanceof AuthorityCorruptionError || error instanceof TypeError)
+            throw error;
+        const lag = registerLag(input.scope, error);
+        const contracts = [];
+        for (const state of states) {
+            contracts.push({
+                contractId: state.id,
+                report: isManagedWorktree(state)
+                    ? { effects: [], lag: [lag], settlement: emptySettlement() }
+                    : await completeReconcile({ ...input, contractId: state.id }),
+            });
+        }
+        return { contracts };
+    }
+    const places = new Map(appointed.appointments.map((appointment) => [appointment.contract, appointment.place]));
+    const retained = await reconcileAllOperation({
+        ...input,
+        retainTerminalWorktree: true,
+        places,
+    });
+    const settlements = await settleAll({
+        repository: input.scope,
+        channel: input.channel,
+        contracts: retained.contracts.map((contract) => ({
+            state: contract.state,
+            effects: contract.report.effects,
+        })),
+    });
+    const cleanup = retained.contracts.some((contract) => isManagedTerminal(contract.state))
+        ? await reconcileAllOperation({ ...input, places })
+        : null;
+    const later = cleanup === null
+        ? null
+        : new Map(cleanup.contracts.map((contract) => [contract.contractId, contract.report]));
+    const released = [];
+    const contracts = [];
+    for (const [index, contract] of retained.contracts.entries()) {
+        const report = later?.get(contract.contractId);
+        if (releaseEligible(contract.state, report, places.has(contract.contractId))) {
+            released.push(contract.contractId);
+        }
+        const projection = await projectContractWorktree(input.scope, contract.state, appointed);
+        contracts.push({
+            contractId: contract.contractId,
+            report: {
+                effects: [...contract.report.effects, ...projection.effects, ...(report?.effects ?? [])],
+                lag: [...contract.report.lag, ...projection.lag, ...(report?.lag ?? [])],
+                settlement: settlements[index],
+            },
+        });
+    }
+    const lag = await releaseAppointments(input.scope, released);
+    return lag === undefined ? { contracts } : attachReleaseLag(contracts, released, lag);
+}

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

@@ -1,6 +1,7 @@
 import type { ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
+import type { ContractDocumentProjection } from "../protocol/operations.js";
 export type RegionOverlap = Readonly<{
     contract: ContractId;
     patterns: readonly Readonly<{
@@ -15,4 +16,15 @@ export type RegionObservation = Readonly<{
     overlapFailure: string;
     overlaps?: never;
 }>;
+export type RegionDeclarationRead = Readonly<{
+    contract: ContractId;
+    patterns: readonly string[];
+}>;
+export declare function readRegionDeclarations(documents: readonly ContractDocumentProjection[]): readonly RegionDeclarationRead[];
+export declare function regionIntersections(left: readonly string[], right: readonly string[]): readonly Readonly<{
+    left: string;
+    right: string;
+}>[];
+export declare function regionPathMatches(patterns: readonly string[], path: string): readonly string[];
+export declare function validateRegionPath(path: unknown): asserts path is string;
 export declare function observeRegion(scope: RepositoryScope, channel: GitDecodeChannel, self: ContractId, mine: readonly string[]): Promise<RegionObservation>;

package/build/src/library/region.js

@@ -1,6 +1,20 @@
 import { decodeContractDocument } from "../body/decode.js";
-import { regionsOverlap } from "../body/region.js";
+import { assertCanonicalRegionPath, regionPatternsMatchPath, regionsOverlap } from "../body/region.js";
 import { documentsOperationAt } from "../protocol/operations.js";
+export function readRegionDeclarations(documents) {
+    return documents.map((document) => ({ contract: document.contract, patterns: decodeContractDocument(document.documentBytes).region }));
+}
+export function regionIntersections(left, right) {
+    return regionsOverlap(left, right).map(([leftPattern, rightPattern]) => ({ left: leftPattern, right: rightPattern }));
+}
+export function regionPathMatches(patterns, path) {
+    return regionPatternsMatchPath(patterns, path);
+}
+export function validateRegionPath(path) {
+    if (typeof path !== "string")
+        throw new Error("Region path must be a string");
+    assertCanonicalRegionPath(path);
+}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }

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

@@ -1,9 +1,8 @@
-import { NoGitWorldError, type ReconcileReport as ProtocolReconcileReport, type RepositoryScope } from "../protocol/operations.js";
-import { type SettlementReport } from "../settlement/settle.js";
+import { NoGitWorldError, type RepositoryScope } from "../protocol/operations.js";
 import { type WorktreeHooks } from "./configuration.js";
-import type { ContractId } from "../core/facts/types.js";
-import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
+import { type RepoContractReconcileReport, type RepoReconcileReport } from "./reconcile.js";
 export { NoGitWorldError };
+export type { RepoContractReconcileReport, RepoReconcileReport };
 export type RepoAtInput = Readonly<{
     path?: string;
 }>;
@@ -11,17 +10,6 @@ export type ReconcileInput = Readonly<{
     hooks?: WorktreeHooks;
     retryHooks?: boolean;
 }>;
-export type RepoContractReconcileReport = Readonly<{
-    effects: readonly (ProtocolReconcileReport["effects"][number] | ContractFileEffect)[];
-    lag: readonly (ProtocolReconcileReport["lag"][number] | ContractFileLag)[];
-    settlement: SettlementReport;
-}>;
-export type RepoReconcileReport = Readonly<{
-    contracts: readonly Readonly<{
-        contractId: ContractId;
-        report: RepoContractReconcileReport;
-    }>[];
-}>;
 export declare function reconcileInput(input: ReconcileInput | undefined): Readonly<{
     hooks: WorktreeHooks;
     retryHooks: boolean;
@@ -29,7 +17,7 @@ export declare function reconcileInput(input: ReconcileInput | undefined): Reado
 export declare class Repo {
     readonly root: string;
     private constructor();
-    static at(input?: RepoAtInput): Repo;
+    static at(input?: RepoAtInput): Promise<Repo>;
     currentBranch(): Promise<string | null>;
     reconcile(input?: ReconcileInput): Promise<RepoReconcileReport>;
 }