@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/library/contract.js

@@ -2,210 +2,35 @@ 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 { renderContractGuidance, resolveHereContractWorkspace, } 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 { observeChangedRegion } from "./region.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
-import { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractObservationOperation, contractsOperation, deliveryDiffOperation, deliveryOperation, stateOperation, } from "../protocol/operations.js";
 import { abandonOperation } from "../protocol/abandon.js";
 import { amendOperation } from "../protocol/amend.js";
 import { arcOperation } from "../protocol/arc.js";
-import { deliverOperation, } from "../protocol/deliver.js";
-import { reviewOperation } from "../protocol/review.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { mintSnapshotId } from "../git/identity.js";
 import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
-import { claimTaskHolderWithFence, releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection, } from "../settlement/holder.js";
-import { parseTaskId } from "../task/identity.js";
+import { releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection } from "../settlement/holder.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
-import { injectedBodyRequests, requestBodyDeliver, requestBodyReview, } from "../akuma/requests.js";
+import { injectedBodyRequests, requestBodyDeliver, requestBodyReview } from "../akuma/requests.js";
 import { auditContract } from "./audit.js";
 import { Delivery, deliveryHandle } from "./delivery.js";
-import { continueDeliveredDependents } from "./continuation.js";
-import { completionInput, completeHolderMutation, completeMutation, } from "./mutation.js";
+import { completionInput, completeHolderMutation, completeMutation } from "./mutation.js";
 import { completeReconcile } from "./reconcile.js";
-import { admitBindWithAppointment } from "./bind.js";
+import { bindFromCli as bindFromCliImplementation, bindKeiyaku as bindKeiyakuImplementation } from "./contract-bind.js";
+import { executeLocalDelivery, executeLocalReview, forwardedReceipt, requireForwarded, } from "./contract-operations.js";
 import { KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
-export { KeiyakuRefused, } from "./refusal.js";
+export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry };
+export { executeForwardedDeliver, executeForwardedReview } from "./contract-operations.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export { Delivery };
-function taskOption(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string")
-        throw new TypeError("task must be a TaskId");
-    try {
-        parseTaskId(value);
-    }
-    catch (error) {
-        throw new TypeError(error instanceof Error ? error.message : "task must be a TaskId");
-    }
-    return value;
-}
-async function resolveHereWorkspace(scope, id) {
-    const appointment = await resolveHereContractWorkspace(scope, id);
-    if (appointment.kind === "failed") {
-        if (appointment.cause === "duplicate")
-            throw new AuthorityCorruptionError(appointment.diagnostic);
-        throw new Error(appointment.diagnostic);
-    }
-    return appointment.kind === "appointed" ? appointment.path : undefined;
-}
-function derivedDocument(state) {
-    return documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
-}
-async function executeLocalDelivery(input) {
-    return withGitDecodeChannel(input.scope, async (channel) => {
-        const outcome = await deliverOperation({
-            scope: input.scope,
-            channel,
-            contractId: input.contractId,
-            deriveDocument: derivedDocument,
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            ...(input.message === undefined ? {} : { message: input.message }),
-            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-            includeDirty: input.includeDirty,
-            materializeConflict: input.materializeConflict,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
-        });
-        if (outcome.kind === "integration-conflict-materialized")
-            return outcome;
-        const accepted = requireAccepted(outcome);
-        const continued = accepted.value.completion === undefined
-            ? accepted
-            : await continueDeliveredDependents({
-                scope: input.scope,
-                channel,
-                contractId: input.contractId,
-                accepted,
-                deriveDocument: derivedDocument,
-                resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-        return completeMutation({
-            ...completionInput(input.scope, channel, input.contractId, (delivery) => delivery, input.hooks),
-            accepted: continued,
-        });
-    });
-}
-async function executeLocalReview(input) {
-    return withGitDecodeChannel(input.scope, async (channel) => {
-        const accepted = requireAccepted(await reviewOperation({
-            scope: input.scope,
-            channel,
-            contractId: input.contractId,
-            deriveDocument: derivedDocument,
-            verdict: input.verdict,
-            ...(input.summary === undefined ? {} : { summary: input.summary }),
-            ...(input.actor === undefined ? {} : { actor: input.actor }),
-            resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
-        }));
-        const continued = accepted.value.completion === undefined
-            ? accepted
-            : await continueDeliveredDependents({
-                scope: input.scope,
-                channel,
-                contractId: input.contractId,
-                accepted,
-                deriveDocument: derivedDocument,
-                resolveHereWorkspace: async (id) => await resolveHereWorkspace(input.scope, id),
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-            });
-        return completeMutation({
-            ...completionInput(input.scope, channel, input.contractId, (review) => review, input.hooks),
-            accepted: continued,
-        });
-    });
-}
-function forwardedReceipt(outcome, action) {
-    if (outcome.kind === "failed") {
-        throw new Error(outcome.failure.kind === "failed"
-            ? outcome.failure.diagnostic
-            : `Unexpected Akuma target failure for ${action}: ${outcome.failure.id}`);
-    }
-    return outcome.result;
-}
-function requireForwardedDelivery(receipt) {
-    if (receipt.kind === "refused")
-        throw new KeiyakuRefused(receipt.refusal);
-    if (receipt.kind === "retry")
-        throw new KeiyakuRetry(receipt.reason);
-    return receipt.kind === "accepted" ? receipt.result : receipt;
-}
-function requireForwardedReview(receipt) {
-    if (receipt.kind === "refused")
-        throw new KeiyakuRefused(receipt.refusal);
-    if (receipt.kind === "retry")
-        throw new KeiyakuRetry(receipt.reason);
-    return receipt.result;
-}
-export async function executeForwardedDeliver(input) {
-    const id = contractId(input.contractId);
-    const actor = actorOption(input.requester).actor;
-    const message = optionalNonblank(input.message, "deliver message");
-    try {
-        const result = await executeLocalDelivery({
-            scope: scopeForRepo(input.repo),
-            contractId: id,
-            ...(actor === undefined ? {} : { actor }),
-            ...(message === undefined ? {} : { message }),
-            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-            includeDirty: input.includeDirty,
-            materializeConflict: input.materializeConflict,
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            hooks: input.hooks,
-        });
-        if (!("facts" in result))
-            return { result };
-        const delivery = result.facts.find((fact) => fact.kind === "deliver");
-        if (delivery === undefined)
-            throw new Error("accepted delivery is missing its journal fact");
-        return { result: { kind: "accepted", result }, deliveryFactId: delivery.entry };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuRefused)
-            return { result: { kind: "refused", refusal: error.refusal } };
-        if (error instanceof KeiyakuRetry)
-            return { result: { kind: "retry", reason: error.reason } };
-        throw error;
-    }
-}
-export async function executeForwardedReview(input) {
-    const id = contractId(input.contractId);
-    const actor = actorOption(input.requester).actor;
-    if (input.verdict !== "satisfied" && input.verdict !== "unsatisfied") {
-        throw new TypeError("verdict must be satisfied or unsatisfied");
-    }
-    const summary = optionalNonblank(input.summary, "review summary");
-    try {
-        const result = await executeLocalReview({
-            scope: scopeForRepo(input.repo),
-            contractId: id,
-            ...(actor === undefined ? {} : { actor }),
-            verdict: input.verdict,
-            ...(summary === undefined ? {} : { summary }),
-            hooks: input.hooks,
-        });
-        const review = result.facts.find((fact) => fact.kind === "attestation");
-        if (review === undefined)
-            throw new Error("accepted review is missing its journal fact");
-        return { result: { kind: "accepted", result }, reviewFactId: review.entry };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuRefused)
-            return { result: { kind: "refused", refusal: error.refusal } };
-        if (error instanceof KeiyakuRetry)
-            return { result: { kind: "retry", reason: error.reason } };
-        throw error;
-    }
-}
 export class KeiyakuHandle {
     id;
     scope;
@@ -235,7 +60,7 @@ export class KeiyakuHandle {
             const commit = observation.snapshot.commit;
             if (commit === null)
                 throw new Error("contract history requires a keiyaku-state snapshot");
-            const recordedAt = (event) => (event.source === "journal" ? event.fact.at : event.dispatch.dispatchedAt);
+            const recordedAt = (event) => event.source === "journal" ? event.fact.at : event.dispatch.dispatchedAt;
             const events = [
                 ...record.entries.map((fact) => ({ source: "journal", fact })),
                 ...dispatches
@@ -267,9 +92,7 @@ export class KeiyakuHandle {
             channel,
             contractId: this.id,
         }));
-        return delivery === null
-            ? null
-            : this.deliveryHandle(delivery);
+        return delivery === null ? null : this.deliveryHandle(delivery);
     }
     async amend(input) {
         const values = requireInput(input, "amend input");
@@ -277,22 +100,25 @@ export class KeiyakuHandle {
         const markdown = values.markdown === undefined ? undefined : requireMarkdown(values.markdown);
         const actor = actorOption(values.actor);
         const gates = values.gates === undefined ? undefined : normalizedGates(values.gates);
-        const prerequisites = values.after === undefined
-            ? undefined
-            : normalizedList(values.after, "after", contractId);
+        const prerequisites = values.after === undefined ? undefined : normalizedList(values.after, "after", contractId);
         if (markdown === undefined && gates === undefined && prerequisites === undefined) {
             throw new TypeError("amend requires markdown, after, or gates");
         }
-        return withGitDecodeChannel(this.scope, async (channel) => {
+        const amendment = await withGitDecodeChannel(this.scope, async (channel) => {
+            let changedSections;
             const accepted = requireAccepted(await amendOperation({
                 scope: this.scope,
                 channel,
                 contractId: this.id,
                 ...actor,
                 deriveAmendment: (source) => {
-                    const document = markdown === undefined
+                    const amendment = markdown === undefined
+                        ? undefined
+                        : applyAmendDocument(markdown, decodeContractDocument(source.document.bytes));
+                    changedSections = amendment?.changedSections;
+                    const document = amendment === undefined
                         ? decodeContractDocument(source.document.bytes)
-                        : decodeContractDocument(applyAmendDocument(markdown, decodeContractDocument(source.document.bytes)));
+                        : decodeContractDocument(amendment.document);
                     const terms = markdown === undefined
                         ? {
                             document: source.document,
@@ -307,16 +133,23 @@ export class KeiyakuHandle {
                     };
                 },
             }));
-            const document = decodeContractDocument(accepted.value.terms.document.bytes);
+            const completed = await completeMutation({
+                ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
+                accepted,
+            });
             return {
-                ...await completeMutation({
-                    ...completionInput(this.scope, channel, this.id, () => undefined, hooks),
-                    accepted,
-                }),
+                completed,
+                document: decodeContractDocument(accepted.value.terms.document.bytes),
+                changedSections,
                 documentDiff: documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes),
-                ...await observeRegion(this.scope, channel, this.id, document.region),
             };
         });
+        const regionObservation = await observeChangedRegion(this.scope, this.id, amendment.changedSections, amendment.document.region);
+        return {
+            ...amendment.completed,
+            documentDiff: amendment.documentDiff,
+            ...regionObservation,
+        };
     }
     async deliver(input) {
         const values = input === undefined ? undefined : requireInput(input, "deliver input");
@@ -340,7 +173,7 @@ export class KeiyakuHandle {
                 ...(signal === undefined ? {} : { signal }),
                 hooks,
             })
-            : requireForwardedDelivery(forwardedReceipt(await requestBodyDeliver({
+            : requireForwarded(forwardedReceipt(await requestBodyDeliver({
                 directory: requests,
                 repoRoot: this.scope.primaryWorktree,
                 contractId: this.id,
@@ -362,7 +195,7 @@ export class KeiyakuHandle {
         const actor = actorOption(values.actor);
         const requests = injectedBodyRequests();
         if (requests !== null) {
-            return requireForwardedReview(forwardedReceipt(await requestBodyReview({
+            return requireForwarded(forwardedReceipt(await requestBodyReview({
                 directory: requests,
                 repoRoot: this.scope.primaryWorktree,
                 contractId: this.id,
@@ -431,7 +264,10 @@ export class KeiyakuHandle {
     async reconcile(input) {
         const options = reconcileInput(input);
         return withGitDecodeChannel(this.scope, (channel) => completeReconcile({
-            scope: this.scope, channel, contractId: this.id, ...options,
+            scope: this.scope,
+            channel,
+            contractId: this.id,
+            ...options,
         }));
     }
     deliveryHandle(delivery) {
@@ -465,11 +301,7 @@ export async function listKeiyaku(input) {
         if (key !== "repo")
             throw new TypeError(`Keiyaku.list input has unknown field: ${key}`);
     const scope = scopeForRepo(values.repo);
-    return withGitDecodeChannel(scope, (channel) => contractsOperation({
-        scope,
-        channel,
-        hereWorkspace: async (id) => await resolveHereContractWorkspace(scope, id),
-    }));
+    return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
 }
 export async function observeKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.observe input");
@@ -486,59 +318,12 @@ export async function observeKeiyaku(input) {
     catch (error) {
         throw new TypeError(error instanceof Error ? error.message : "contract ID is invalid");
     }
-    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({
-        scope,
-        channel,
-        contractId: id,
-        hereWorkspace: async (contract) => await resolveHereContractWorkspace(scope, contract),
-    }));
+    return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
 }
 export async function bindKeiyaku(input) {
-    const values = requireInput(input, "Keiyaku.bind input");
-    const hooks = worktreeHooksOption(values.hooks);
-    const scope = scopeForRepo(values.repo);
-    const markdown = requireMarkdown(values.markdown);
-    const task = taskOption(values.task);
-    const document = decodeContractDocument(markdown);
-    const workspace = values.workspace === undefined ? "worktree" : values.workspace;
-    if (workspace !== "worktree" && workspace !== "here")
-        throw new TypeError("workspace must be worktree or here");
-    const target = values.target;
-    if (target !== undefined && typeof target !== "string")
-        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));
-    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({ ...completionInput(scope, channel, id, toHandle, hooks), accepted })
-            : await completeHolderMutation({
-                completion: completionInput(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),
-        };
-    });
+    return bindKeiyakuImplementation(input, (id, scope) => new KeiyakuHandle(id, scope));
+}
+/** Internal CLI composition; not exported from the package root. */
+export async function bindFromCli(input) {
+    return bindFromCliImplementation(input, (id, scope) => new KeiyakuHandle(id, scope));
 }

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

@@ -59,6 +59,7 @@ export type AkumaTellResult = Readonly<{
     tell: TellResult;
     observation: AkumaObservationStage;
 }>;
+export type { TellResult, TellWake } from "../akuma/index.js";
 export type AkumaInterruptInput = AkumaAddressInput & Readonly<{
     body: string;
 }>;
@@ -120,4 +121,3 @@ export declare function killAkuma(input: AkumaSetAddressInput): Promise<AkumaKil
 export declare function tellAkuma(input: AkumaTellInput): Promise<AkumaTellResult>;
 export declare function interruptAkuma(input: AkumaInterruptInput): Promise<AkumaInterruptResult>;
 export declare function historyAkuma(input: AkumaHistoryInput): Promise<AkumaHistoryResult>;
-export {};

package/build/src/library/fleet.js

@@ -1,4 +1,4 @@
-import { Akuma, AkumaNotBornError, } from "../akuma/index.js";
+import { Akuma, AkumaNotBornError, defaultWaitComplete, } from "../akuma/index.js";
 import { readBudgetedStatus, tellAkumaWithId } from "../akuma/akuma.js";
 import { injectedBodyRequests, requestBodyKill, requestBodyTell, requestBodyWait, } from "../akuma/requests.js";
 import { readDispatch } from "../dispatch/index.js";
@@ -43,7 +43,8 @@ async function observeAkuma(status, path, repo) {
 }
 async function observeAkumaStage(path, id, repo) {
     try {
-        return { kind: "observed", ...await observeAkuma(await source(path).of({ id }).status(), path, repo) };
+        const observed = await readBudgetedStatus(path, id, { aperture: "receipt" });
+        return { kind: "observed", ...(await observeAkuma(observed.status, path, repo)) };
     }
     catch (error) {
         if (error instanceof AkumaNotBornError)
@@ -87,6 +88,7 @@ function delay(milliseconds, signal) {
     });
 }
 const SHARED_ORDINARY_BUDGET = 30;
+const POLL_MS = 100;
 async function observeWaitRound(path, ids, signal) {
     signal?.throwIfAborted();
     if (ids.length <= 1) {
@@ -101,7 +103,7 @@ async function observeWaitRound(path, ids, signal) {
     for (const id of ids) {
         signal?.throwIfAborted();
         try {
-            const observed = await readBudgetedStatus(path, id, { ordinaryBudget: remaining });
+            const observed = await readBudgetedStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
             statuses.push(observed.status);
             remaining -= observed.ordinarySelected;
         }
@@ -117,18 +119,16 @@ export async function executeWaitAkuma(input) {
     const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
     for (;;) {
         const round = await observeWaitRound(input.path, input.ids, input.signal);
-        const settled = round.statuses.map((status) => status.life !== "running");
-        const completed = round.statuses.length > 0
-            && (input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean));
-        if (completed
-            || (deadline !== undefined && performance.now() >= deadline)) {
+        const settled = round.statuses.map(defaultWaitComplete);
+        const completed = round.statuses.length > 0 && (input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean));
+        if (completed || (deadline !== undefined && performance.now() >= deadline)) {
             return {
                 completion: input.completion,
                 observations: await observeAkumaSet(round.statuses, input.path, input.repo),
                 unobserved: round.unobserved,
             };
         }
-        await delay(deadline === undefined ? 25 : Math.min(25, Math.max(0, deadline - performance.now())), input.signal);
+        await delay(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())), input.signal);
     }
 }
 export async function executeTellAkuma(input) {
@@ -136,7 +136,13 @@ export async function executeTellAkuma(input) {
     const handle = source(input.path).of({ id: input.id });
     const tell = input.tellId === undefined
         ? await handle.tell(input.body)
-        : await tellAkumaWithId(input.path, input.id, input.body, input.tellId, input.recordedAt);
+        : await tellAkumaWithId({
+            worldPath: input.path,
+            id: input.id,
+            body: input.body,
+            tellId: input.tellId,
+            ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
+        });
     input.signal?.throwIfAborted();
     return {
         akuma: input.id,
@@ -186,7 +192,9 @@ async function attachWaitContracts(repo, result) {
         };
 }
 async function attachTellContract(repo, result) {
-    return repo === undefined ? result : { ...result, observation: await attachObservationStage(repo, result.observation) };
+    return repo === undefined
+        ? result
+        : { ...result, observation: await attachObservationStage(repo, result.observation) };
 }
 async function attachKillContracts(repo, result) {
     return repo === undefined

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

@@ -1,11 +1,13 @@
 import type { DecodedContractDocument } from "../body/types.js";
 import { type ActorId, type ContractId, type ContractTerms, type Gate } from "../core/facts/types.js";
+import { type TaskId } from "../task/identity.js";
 import type { DocumentDerivation } from "../protocol/operations.js";
 export declare function actorOption(actor: unknown): Readonly<{
     actor?: ActorId;
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+export declare function taskOption(value: unknown): TaskId | undefined;
 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;

package/build/src/library/input.js

@@ -1,5 +1,6 @@
 import { verificationDefinition } from "../body/decode.js";
 import { actorId, gate, gateWord, } from "../core/facts/types.js";
+import { parseTaskId } from "../task/identity.js";
 import { prepareVerificationDeclaration } from "../verification/declaration.js";
 export function actorOption(actor) {
     if (actor === undefined)
@@ -22,6 +23,19 @@ export function requireInput(value, label) {
         throw new TypeError(`${label} must be an object`);
     return value;
 }
+export function taskOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError("task must be a TaskId");
+    try {
+        parseTaskId(value);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : "task must be a TaskId");
+    }
+    return value;
+}
 export function optionalNonblank(value, label) {
     if (value === undefined)
         return undefined;

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

@@ -4,25 +4,26 @@ import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAk
 import { listCatalog } from "./catalog.js";
 import { nukeKeiyaku } from "./nuke.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
+export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
-export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, 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 { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, AfterEndpointObservation, ContractAfterEdge, ContractBoard, ContractDependent, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContractWorkspaceObservation, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, 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";
-export type { ReconcileInput, RepoAtInput, RepoReconcileReport, } from "./repo.js";
-export type { SettlementAction, SettlementLag, SettlementReport, } from "../settlement/settle.js";
+export type { ReconcileInput, RepoAtInput, RepoReconcileReport } from "./repo.js";
+export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
 export type { AliasStage, AkumaStatus, CallObservation, CallInput, CallResult, DispatchStage, ForkInput, ForkResult, IntegrationFailure, } from "./akuma-creation.js";
 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 { TellResult, TellWake } from "./fleet.js";
 export type { AllowedAction, AllowedActions } from "../akuma/allowed.js";
 export type { Catalog, CatalogInput, CatalogQuery } from "./catalog.js";
-export type { NukeInput, NukeResult, } from "./nuke.js";
+export type { NukeInput, NukeResult } from "./nuke.js";
 export type { NukeConfirmationRefusal, NukeConfirmationRequiredRefusal } from "./refusal.js";
 export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
 export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellInput, AkumaUnobserved, CreatedTaskObservation, DispatchAssociation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";

package/build/src/library/keiyaku.js

@@ -1,12 +1,12 @@
 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 { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
 import { listCatalog } from "./catalog.js";
 import { nukeKeiyaku } from "./nuke.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-export { Delivery, KeiyakuRefused, KeiyakuRetry, } from "./contract.js";
+export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
-export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom, } from "./configuration.js";
+export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
 export const Keiyaku = Object.freeze({
     prototype: KeiyakuHandle.prototype,

package/build/src/library/nuke.js

@@ -1,3 +1,5 @@
+import { rmdir } from "node:fs/promises";
+import { resolve } from "node:path";
 import { stopAkuma } from "../akuma/nuke.js";
 import { nukeGit } from "../git/nuke.js";
 import { nukeTask } from "../task/operations.js";
@@ -6,6 +8,16 @@ import { requireInput, requireMarkdown } from "./input.js";
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
+async function removeEmptyWorldMarker(world) {
+    try {
+        await rmdir(resolve(world, ".keiyaku"));
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTEMPTY")
+            throw error;
+    }
+}
 function nukeInput(input) {
     const value = requireInput(input, "nuke input");
     const world = requireMarkdown(value.world, "world");
@@ -39,13 +51,10 @@ export async function nukeKeiyaku(input) {
                 }
             }
         };
-        await Promise.all([
-            attempt(deleteAkuma()),
-            attempt(nukeGit(value.world)),
-            attempt(nukeTask(value.world)),
-        ]);
+        await Promise.all([attempt(deleteAkuma()), attempt(nukeGit(value.world)), attempt(nukeTask(value.world))]);
         if (failed)
             throw firstDiagnostic;
+        await removeEmptyWorldMarker(value.world);
         return { kind: "success", world: value.world };
     }
     catch (error) {

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

@@ -11,11 +11,16 @@ export type ReconcileCompletion = Readonly<{
     settlement: SettlementReport;
 }>;
 export type RepoContractReconcileReport = ReconcileCompletion;
+type RepoReconcileContracts = readonly Readonly<{
+    contractId: ContractId;
+    report: RepoContractReconcileReport;
+}>[];
 export type RepoReconcileReport = Readonly<{
-    contracts: readonly Readonly<{
-        contractId: ContractId;
-        report: RepoContractReconcileReport;
-    }>[];
+    kind: "completed";
+    contracts: RepoReconcileContracts;
+}> | Readonly<{
+    kind: "world-observation-failed";
+    diagnostic: string;
 }>;
 type ReconcileOptions = Readonly<{
     scope: RepositoryScope;