@astrosheep/keiyaku 4.0.1 → 4.0.2

package/build/src/library/address.js

@@ -1,11 +1,20 @@
 import { readAliases } from "../alias/index.js";
 import { Akuma } from "../akuma/akuma.js";
+import { probeBornAkuma } from "../akuma/index.js";
 import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
 import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
+export class AkumaWorldScopeError extends TypeError {
+    refusal;
+    constructor(refusal) {
+        super(`akuma-not-in-world ${refusal.world} ${refusal.ids.join(" ")}`);
+        this.name = "AkumaWorldScopeError";
+        this.refusal = refusal;
+    }
+}
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0)
         throw new TypeError(`${label} must be a nonblank string`);
@@ -22,17 +31,17 @@ function settingsOption(value) {
 function world(path, settings) {
     return Akuma.of(path, settings);
 }
-function directId(path, selector) {
+async function directId(path, selector) {
     if (selector.startsWith("@")) {
         const alias = parseAkumaAlias(selector);
-        const resolved = readAliases(path).find((binding) => binding.alias === alias)?.akuId ?? null;
+        const resolved = (await readAliases(path)).find((binding) => binding.alias === alias)?.akuId ?? null;
         if (resolved === null)
             throw new TypeError(`unknown Akuma alias: ${alias}`);
         return resolved;
     }
     return parseAkuId(selector).id;
 }
-export function resolveNamedAddress(input) {
+export async function resolveNamedAddress(input) {
     const selector = nonblank(input.selector, "selector");
     if (selector.startsWith("kei/"))
         return { kind: "contract", id: contractId(selector) };
@@ -44,7 +53,7 @@ export function resolveNamedAddress(input) {
         && `@${row.id.slice("kei/".length)}` === alias);
     const aliasId = input.path === null
         ? null
-        : readAliases(input.path).find((binding) => binding.alias === alias)?.akuId ?? null;
+        : (await readAliases(input.path)).find((binding) => binding.alias === alias)?.akuId ?? null;
     if (contractMatches.length > 0 && aliasId !== null)
         throw new TypeError(`ambiguous selector matches Contract and Akuma: ${selector}`);
     if (contractMatches.length === 1)
@@ -55,7 +64,7 @@ export function resolveNamedAddress(input) {
         return { kind: "akuma", id: aliasId };
     throw new TypeError(`unknown selector: ${selector}`);
 }
-export function addressAkuma(input) {
+export async function addressAkuma(input) {
     const values = requireInput(input, "Akuma address input");
     for (const key of Object.keys(values)) {
         if (!["path", "akuma", "settings", "repo"].includes(key))
@@ -65,11 +74,61 @@ export function addressAkuma(input) {
         scopeForRepo(values.repo);
     const path = nonblank(values.path, "path");
     const settings = settingsOption(values.settings);
-    return { path, id: directId(path, nonblank(values.akuma, "akuma")), ...(settings === undefined ? {} : { settings }) };
+    return { path, id: await directId(path, nonblank(values.akuma, "akuma")), ...(settings === undefined ? {} : { settings }) };
 }
 function idsFromFleet(fleet) {
     return fleet.rows.map((row) => row.id);
 }
+function parseSetSelector(raw) {
+    const selector = nonblank(raw, "akuma selector");
+    if (selector.startsWith("kei/"))
+        return { kind: "contract", value: contractId(selector) };
+    if (selector.includes("*"))
+        return { kind: "glob", value: parseAkumaGlob(selector) };
+    if (selector.startsWith("@"))
+        return { kind: "alias", value: parseAkumaAlias(selector) };
+    return { kind: "direct", value: parseAkuId(selector).id };
+}
+function hasSelectorKind(selectors, kind) {
+    return selectors.some((selector) => selector.kind === kind);
+}
+function addSelectorIds(selector, sources, selected, contractMembers) {
+    if (selector.kind === "contract") {
+        for (const dispatch of sources.dispatches) {
+            if (dispatch.contractId !== selector.value)
+                continue;
+            selected.add(dispatch.akuId);
+            contractMembers.add(dispatch.akuId);
+        }
+        return;
+    }
+    if (selector.kind === "glob") {
+        for (const id of sources.fleetIds)
+            if (matchesAkumaGlob(selector.value, id))
+                selected.add(id);
+        return;
+    }
+    if (selector.kind === "alias") {
+        const id = sources.aliases.get(selector.value);
+        if (id === undefined)
+            throw new TypeError(`unknown Akuma alias: ${selector.value}`);
+        selected.add(id);
+        return;
+    }
+    selected.add(selector.value);
+}
+async function contractMemberInWorld(path, id) {
+    return await probeBornAkuma(path, id);
+}
+async function refuseForeignContractMembers(path, ids, contractMembers) {
+    const foreign = [];
+    for (const id of ids) {
+        if (contractMembers.has(id) && !await contractMemberInWorld(path, id))
+            foreign.push(id);
+    }
+    if (foreign.length > 0)
+        throw new AkumaWorldScopeError({ kind: "akuma-not-in-world", ids: foreign, world: path });
+}
 export async function addressAkumaSet(input) {
     const values = requireInput(input, "Akuma set address input");
     for (const key of Object.keys(values)) {
@@ -80,55 +139,27 @@ export async function addressAkumaSet(input) {
         throw new TypeError("akuma must be a nonempty selector array");
     const path = nonblank(values.path, "path");
     const settings = settingsOption(values.settings);
-    const selectors = values.akuma.map((raw) => {
-        const selector = nonblank(raw, "akuma selector");
-        if (selector.startsWith("kei/"))
-            return { kind: "contract", value: contractId(selector) };
-        if (selector.includes("*"))
-            return { kind: "glob", value: parseAkumaGlob(selector) };
-        if (selector.startsWith("@"))
-            return { kind: "alias", value: parseAkumaAlias(selector) };
-        return { kind: "direct", value: parseAkuId(selector).id };
-    });
-    if (selectors.some((selector) => selector.kind === "contract") && values.repo === undefined) {
+    const selectors = values.akuma.map(parseSetSelector);
+    if (hasSelectorKind(selectors, "contract") && values.repo === undefined) {
         throw new TypeError("Contract Akuma selector requires repo");
     }
-    const fleetIds = selectors.some((selector) => selector.kind === "glob")
-        ? idsFromFleet(world(path, settings).list())
+    const fleetIds = hasSelectorKind(selectors, "glob")
+        ? idsFromFleet(await world(path, settings).list())
         : [];
-    const aliases = selectors.some((selector) => selector.kind === "alias")
-        ? new Map(readAliases(path).map((binding) => [binding.alias, binding.akuId]))
+    const aliases = hasSelectorKind(selectors, "alias")
+        ? new Map((await readAliases(path)).map((binding) => [binding.alias, binding.akuId]))
         : new Map();
-    const dispatches = selectors.some((selector) => selector.kind === "contract")
+    const dispatches = hasSelectorKind(selectors, "contract")
         ? await readDispatches(scopeForRepo(values.repo))
         : [];
     const selected = new Set();
-    for (const selector of selectors) {
-        if (selector.kind === "contract") {
-            const members = dispatches
-                .filter((dispatch) => dispatch.contractId === selector.value)
-                .map((dispatch) => dispatch.akuId);
-            for (const id of members)
-                selected.add(id);
-            continue;
-        }
-        if (selector.kind === "glob") {
-            for (const id of fleetIds)
-                if (matchesAkumaGlob(selector.value, id))
-                    selected.add(id);
-            continue;
-        }
-        if (selector.kind === "alias") {
-            const id = aliases.get(selector.value);
-            if (id === undefined)
-                throw new TypeError(`unknown Akuma alias: ${selector.value}`);
-            selected.add(id);
-        }
-        else
-            selected.add(selector.value);
-    }
+    const contractMembers = new Set();
+    const sources = { fleetIds, aliases, dispatches };
+    for (const selector of selectors)
+        addSelectorIds(selector, sources, selected, contractMembers);
     const ids = [...selected].sort((left, right) => Buffer.compare(Buffer.from(left), Buffer.from(right)));
     if (ids.length === 0)
         throw new TypeError("Akuma selector snapshot is empty");
+    await refuseForeignContractMembers(path, ids, contractMembers);
     return { path, ids, ...(settings === undefined ? {} : { settings }) };
 }

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

@@ -1,5 +1,5 @@
 import { type AliasBinding } from "../alias/index.js";
-import { type AkumaStatus, type ForkReceipt } from "../akuma/akuma.js";
+import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
 import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
@@ -57,6 +57,11 @@ export type CallObservation = Readonly<{
 export type CallResult = Readonly<{
     kind: "called";
     akuma: AkuId;
+    readonly?: ReadonlyRestraint;
+    execution: Readonly<{
+        cwd: string;
+        source: "input" | "world" | "contract-worktree";
+    }>;
     dispatch: DispatchStage;
     alias: AliasStage;
     observation: CallObservation;

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

@@ -1,11 +1,13 @@
+import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma } from "../akuma/akuma.js";
+import { Akuma, } from "../akuma/akuma.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch, } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
+import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
-import { seatForKeiyaku } from "./contract.js";
+import { KeiyakuRefused, seatForKeiyaku } from "./contract.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
     if (typeof value !== "string" || value.trim().length === 0) {
@@ -67,9 +69,9 @@ async function observeCall(handle, mode, timeoutMs) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-function dispatchStage(input) {
+async function dispatchStage(input) {
     try {
-        const published = publishDispatch(input);
+        const published = await publishDispatch(input);
         return published.kind === "dispatched"
             ? { kind: "dispatched", dispatch: published.dispatch }
             : { kind: "failed", failure: published.failure };
@@ -78,17 +80,74 @@ function dispatchStage(input) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-function forkDispatchStage(input) {
+async function forkDispatchStage(input) {
     try {
-        const parent = readDispatch(input.repository, input.parent);
+        const parent = await readDispatch(input.repository, input.parent);
         return parent === null
             ? { kind: "none" }
-            : dispatchStage({ repository: input.repository, akuId: input.child, contractId: parent.contractId });
+            : await dispatchStage({ repository: input.repository, akuId: input.child, contractId: parent.contractId });
     }
     catch (error) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
+async function canonicalizeExistingDirectory(path, diagnostic) {
+    try {
+        const real = await realpath(path);
+        if (!(await stat(real)).isDirectory())
+            throw new Error(diagnostic);
+        return real;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === diagnostic)
+            throw error;
+        throw new Error(diagnostic);
+    }
+}
+function unavailableWorkspace(contractId, detail) {
+    return new Error(`Contract workspace is unavailable: ${contractId} ${detail}`);
+}
+async function currentManagedContract(contract, contractId) {
+    let state;
+    try {
+        state = await contract.state();
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === `contract does not exist: ${contractId}`) {
+            throw new KeiyakuRefused({ kind: "contract-missing", contractId });
+        }
+        throw error;
+    }
+    if (state.terminal !== null)
+        throw new KeiyakuRefused({ kind: "terminal", contractId: state.id });
+    if (state.coordinates.workspace !== "worktree") {
+        throw unavailableWorkspace(state.id, "is here");
+    }
+    return state;
+}
+async function resolveCallExecution(input) {
+    if (input.cwd !== undefined) {
+        return {
+            cwd: await canonicalizeExistingDirectory(input.cwd, `cwd is not an existing directory: ${input.cwd}`),
+            source: "input",
+        };
+    }
+    if (input.contract === undefined)
+        return { cwd: input.path, source: "world" };
+    const seat = seatForKeiyaku(input.contract);
+    const state = await currentManagedContract(input.contract, seat.id);
+    const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
+    if (appointment.kind === "unappointed") {
+        throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
+    }
+    if (appointment.kind === "failed") {
+        throw new Error(`${appointment.diagnostic}; use reconcile`);
+    }
+    return {
+        cwd: await canonicalizeExistingDirectory(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
+        source: "contract-worktree",
+    };
+}
 export async function callKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, ["path", "archetype", "body", "cwd", "mode", "timeoutMs", "settings", "contract", "alias"], "Keiyaku.call input");
@@ -103,14 +162,20 @@ export async function callKeiyaku(input) {
         ? undefined
         : parseAkumaAlias(nonblank(values.alias, "alias"));
     const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
+    const execution = await resolveCallExecution({
+        path,
+        ...(cwd === undefined ? {} : { cwd }),
+        ...(seat === undefined ? {} : { contract: values.contract }),
+    });
     const handle = await Akuma.of(path, settings).call({
         archetype,
         body,
-        ...(cwd === undefined ? {} : { cwd }),
+        cwd: execution.cwd,
     });
+    const readonly = (await handle.status()).readonly;
     const dispatch = seat === undefined
         ? { kind: "none" }
-        : dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
+        : await dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
     let aliasStage = { kind: "none" };
     if (alias !== undefined) {
         if (dispatch.kind === "failed")
@@ -126,7 +191,15 @@ export async function callKeiyaku(input) {
         }
     }
     const observation = await observeCall(handle, mode, timeoutMs);
-    return { kind: "called", akuma: handle.id, dispatch, alias: aliasStage, observation };
+    return {
+        kind: "called",
+        akuma: handle.id,
+        ...(readonly === undefined ? {} : { readonly }),
+        execution,
+        dispatch,
+        alias: aliasStage,
+        observation,
+    };
 }
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
@@ -134,11 +207,11 @@ export async function forkKeiyaku(input) {
     const path = nonblank(values.path, "path");
     const at = nonblank(values.at, "at");
     const settings = settingsOption(values.settings);
-    const akuma = addressAkuma({
+    const akuma = (await addressAkuma({
         path,
         akuma: nonblank(values.akuma, "akuma"),
         ...(settings === undefined ? {} : { settings }),
-    }).id;
+    })).id;
     const repository = values.repo === undefined ? undefined : scopeForRepo(values.repo);
     const receipt = await Akuma.of(path, settings)
         .of({ id: akuma })
@@ -147,6 +220,6 @@ export async function forkKeiyaku(input) {
         return { ...receipt, parent: akuma };
     const dispatch = repository === undefined
         ? { kind: "none" }
-        : forkDispatchStage({ repository, parent: akuma, child: receipt.child });
+        : await forkDispatchStage({ repository, parent: akuma, child: receipt.child });
     return { kind: "forked", parent: akuma, child: receipt.child, dispatch };
 }

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

@@ -0,0 +1,18 @@
+import type { ContractId } from "../core/facts/types.js";
+import { type AuditReport, type RepositoryScope } from "../protocol/operations.js";
+import { type WorktreeHooks } from "./configuration.js";
+import { type MutationResult } from "./mutation.js";
+export type AuditInput = Readonly<{
+    actor?: string;
+    hooks?: WorktreeHooks;
+    includeDirty?: boolean;
+    showDiff?: boolean;
+    requireBranchesToBeUpToDate?: boolean;
+    signal?: AbortSignal;
+}>;
+/** Normalize public audit input and project the protocol audit operation. */
+export declare function auditContract(input: Readonly<{
+    scope: RepositoryScope;
+    contractId: ContractId;
+    input?: AuditInput;
+}>): Promise<MutationResult<AuditReport>>;

package/build/src/library/audit.js

@@ -0,0 +1,44 @@
+import { decodeContractDocument } from "../body/decode.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { auditOperation, } from "../protocol/operations.js";
+import { worktreeHooksOption } from "./configuration.js";
+import { actorOption, documentDerivation, optionalBoolean, optionalSignal, requireInput, } from "./input.js";
+import { completeMutation } from "./mutation.js";
+import { requireAccepted } from "./refusal.js";
+function normalizeAuditInput(input) {
+    const values = input === undefined ? undefined : requireInput(input, "audit input");
+    const signal = optionalSignal(values?.signal);
+    return {
+        hooks: worktreeHooksOption(values?.hooks),
+        ...actorOption(values?.actor),
+        includeDirty: optionalBoolean(values?.includeDirty, "includeDirty") ?? false,
+        showDiff: optionalBoolean(values?.showDiff, "showDiff") ?? false,
+        requireBranchesToBeUpToDate: optionalBoolean(values?.requireBranchesToBeUpToDate, "requireBranchesToBeUpToDate") ?? false,
+        ...(signal === undefined ? {} : { signal }),
+    };
+}
+/** Normalize public audit input and project the protocol audit operation. */
+export async function auditContract(input) {
+    const normalized = normalizeAuditInput(input.input);
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const accepted = requireAccepted(await auditOperation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
+            includeDirty: normalized.includeDirty,
+            showDiff: normalized.showDiff,
+            requireBranchesToBeUpToDate: normalized.requireBranchesToBeUpToDate,
+            ...(normalized.signal === undefined ? {} : { signal: normalized.signal }),
+            ...(normalized.actor === undefined ? {} : { actor: normalized.actor }),
+        }));
+        return completeMutation({
+            scope: input.scope,
+            channel,
+            contractId: input.contractId,
+            accepted,
+            value: (report) => report,
+            hooks: normalized.hooks,
+        });
+    });
+}

package/build/src/library/bind.js

@@ -30,7 +30,7 @@ async function attemptCandidates(input) {
         const id = candidateId(input.title, collision);
         let reserved = false;
         if (input.workspace === "here") {
-            const reservation = reserveContractWorktree(input.scope, id);
+            const reservation = await reserveContractWorktree(input.scope, id);
             if (reservation.kind !== "reserved") {
                 return { kind: "refused", refusal: {
                         kind: "here-worktree-appointed",
@@ -44,13 +44,13 @@ async function attemptCandidates(input) {
         if (result.kind === "accepted")
             return result;
         if (reserved)
-            releaseContractWorktree(input.scope, id);
+            await releaseContractWorktree(input.scope, id);
         if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
             return result;
     }
     throw new Error("contract identity collision attempts exhausted");
 }
-export function admitBindWithAppointment(input) {
+export async function admitBindWithAppointment(input) {
     const action = () => attemptCandidates(input);
-    return input.workspace === "here" ? withContractWorktreeAppointment(input.scope, action) : action();
+    return input.workspace === "here" ? await withContractWorktreeAppointment(input.scope, action) : action();
 }

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

@@ -1,7 +1,7 @@
 import { type AkumaList } from "../akuma/akuma.js";
 import { type ArchetypeCatalogRow } from "../akuma/archetype.js";
 import type { Settings } from "../settings.js";
-import { type TaskRow } from "../task/index.js";
+import type { TaskRow } from "../task/index.js";
 import { type ContractBoard } from "./contract.js";
 import { Repo } from "./repo.js";
 import type { WorldRoot } from "../world.js";

package/build/src/library/catalog.js

@@ -1,6 +1,6 @@
 import { Akuma } from "../akuma/akuma.js";
 import { listArchetypeDefinitions } from "../akuma/archetype.js";
-import { Tasks } from "../task/index.js";
+import { observeTaskCatalogRows } from "../task/operations.js";
 import { listKeiyaku } from "./contract.js";
 import { requireInput } from "./input.js";
 import { Repo } from "./repo.js";
@@ -32,7 +32,7 @@ function queryValue(value) {
     if (query.kind !== "akuma")
         return { kind: query.kind };
     if (query.archetype !== undefined && typeof query.archetype !== "string") {
-        throw new TypeError("Keiyaku.ls Akuma archetype must be a string");
+        throw new TypeError("Keiyaku.ls Akuma name must be a string");
     }
     return { kind: "akuma", ...(query.archetype === undefined ? {} : { archetype: query.archetype }) };
 }
@@ -52,16 +52,13 @@ export async function listCatalog(input) {
         return { kind: "contracts", root: board.root, state: board.state, rows: board.rows };
     }
     if (query.kind === "archetypes") {
-        return { kind: "archetypes", rows: listArchetypeDefinitions({ settings: settingsValue(values.settings) }) };
+        return { kind: "archetypes", rows: await listArchetypeDefinitions({ settings: settingsValue(values.settings) }) };
     }
     const path = worldRoot(values.path);
     if (query.kind === "tasks") {
-        const result = await Tasks.of(path).list({ selection: "all", scope: "world" });
-        if (result.kind !== "accepted")
-            throw new Error(`Task catalog ${result.kind}: ${JSON.stringify(result)}`);
-        return { kind: "tasks", root: path, rows: result.value };
+        return { kind: "tasks", root: path, rows: await observeTaskCatalogRows(path) };
     }
-    const listed = Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
+    const listed = await Akuma.of(path).list(query.archetype === undefined ? undefined : { archetype: query.archetype });
     return {
         kind: "akuma",
         root: path,

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

@@ -3,23 +3,24 @@ import { type RegionObservation, type RegionOverlap } from "./region.js";
 import { type Gate, type WorktreeHooks } from "./configuration.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 FactKind, 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 TaskId } from "../task/identity.js";
 import { Repo, type ReconcileInput } from "./repo.js";
+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, ChangeId, ContractId, ContractState, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, FactKind, SnapshotId, TimelineEntry, };
+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 { PlacementStop, VerificationStop };
+export type { PlacementStop, VerificationReuse, VerificationStop };
 export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
 export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
 export type { MutationResult };
@@ -89,9 +90,7 @@ export type DeliverInput = ActorOptions & Readonly<{
     includeDirty?: boolean;
     signal?: AbortSignal;
 }>;
-export type AuditInput = ActorOptions & Readonly<{
-    signal?: AbortSignal;
-}>;
+export type { AuditInput };
 export declare class KeiyakuHandle {
     private readonly id;
     private readonly scope;

package/build/src/library/contract.js

@@ -2,20 +2,21 @@ 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 { projectContractWorktree, renderContractGuidance, } from "../contract-worktree.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 { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { abandonOperation, amendOperation, arcOperation, auditOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reconcileOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
+import { abandonOperation, amendOperation, arcOperation, contractObservationOperation, contractsOperation, deliveryDiffOperation, deliverOperation, deliveryOperation, reviewOperation, stateOperation, } from "../protocol/operations.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
-import { settle } from "../settlement/settle.js";
 import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
 import { parseTaskId } from "../task/identity.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
+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";
@@ -197,42 +198,17 @@ export class KeiyakuHandle {
         });
     }
     async audit(input) {
-        const values = input === undefined ? undefined : requireInput(input, "audit input");
-        const hooks = worktreeHooksOption(values?.hooks);
-        const actor = actorOption(values?.actor);
-        const signal = optionalSignal(values?.signal);
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const accepted = requireAccepted(await auditOperation({
-                scope: this.scope,
-                channel,
-                contractId: this.id,
-                deriveDocument: (state) => documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id),
-                ...(signal === undefined ? {} : { signal }),
-                ...actor,
-            }));
-            return completeMutation({
-                ...completion(this.scope, channel, this.id, (report) => report, hooks),
-                accepted,
-            });
+        return auditContract({
+            scope: this.scope,
+            contractId: this.id,
+            ...(input === undefined ? {} : { input }),
         });
     }
     async reconcile(input) {
         const options = reconcileInput(input);
-        return withGitDecodeChannel(this.scope, async (channel) => {
-            const retained = await reconcileOperation({ scope: this.scope, channel, contractId: this.id, ...options, retainTerminalWorktree: true });
-            const projection = projectContractWorktree(this.scope, retained.state);
-            const settlement = await settle({ repository: this.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: this.scope, channel, contractId: this.id, ...options })
-                : null;
-            return {
-                effects: [...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
-                lag: [...retained.report.lag, ...projection.lag, ...(cleanup?.report.lag ?? [])],
-                settlement,
-            };
-        });
+        return withGitDecodeChannel(this.scope, (channel) => completeReconcile({
+            scope: this.scope, channel, contractId: this.id, ...options,
+        }));
     }
     deliveryHandle(delivery) {
         return deliveryHandle(delivery, () => deliveryDiffOperation({

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

@@ -3,6 +3,7 @@ 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"];
@@ -10,7 +11,7 @@ declare class DeliveryHandle {
     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" | "placement" | "cleanup" | "leak">>);
+    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;