@astrosheep/keiyaku 4.6.7 → 4.6.9

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

@@ -7,26 +7,32 @@ import { withGitDecodeChannel } from "../git/read-observation.js";
 import { executionStop, isOperationalFailure, isOperationalStop } from "../protocol/progress.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { admitForkBindWithAppointment, prepareMarkdownBind } from "./bind.js";
-import { acceptedOutcome, conclusions, expected, retainAdmission } from "./contract-outcomes.js";
+import { acceptedOutcome, expected, retainAdmission } from "./contract-outcomes.js";
 import { captureLocalContractComposition, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
-import { actorOption, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
+import { actorOption, normalizedList, requireInput, requireMarkdown, debtOption } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
 import { project, validated } from "./outcome.js";
 import { reconcileAffectedContracts } from "./reconcile.js";
 import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
+/** The one place a caller's omitted target becomes product behavior. */
+function bindTargetSelection(target) {
+    if (target === undefined)
+        return { kind: "current-branch" };
+    return target === null ? { kind: "targetless" } : { kind: "explicit", target };
+}
 function bindInput(input, composition) {
     return validated(() => {
         const values = requireInput(input, "Keiyaku.bind input");
         const forkOf = values.forkOf;
         const allowed = forkOf === undefined
-            ? ["repo", "markdown", "task", "target", "workspace", "actor", "after", "gates"]
+            ? ["repo", "markdown", "debt", "target", "workspace", "actor", "after", "gates"]
             : ["repo", "forkOf", "target", "workspace", "actor"];
         requireInput(input, "Keiyaku.bind input", allowed);
         if ((values.workspace ?? "worktree") !== "worktree")
             throw new TypeError("workspace must be worktree");
-        if (values.target !== undefined && typeof values.target !== "string")
-            throw new TypeError("target must be a string");
+        if (values.target !== undefined && values.target !== null && typeof values.target !== "string")
+            throw new TypeError("target must be a string or null");
         const actor = actorOption(values.actor);
         const document = forkOf === undefined ? parseMarkdown(requireMarkdown(values.markdown)) : undefined;
         if (forkOf !== undefined) {
@@ -40,18 +46,17 @@ function bindInput(input, composition) {
             document,
             actor,
             target: values.target,
-            task: forkOf === undefined ? taskOption(values.task) : undefined,
+            debt: forkOf === undefined ? debtOption(values.debt) : undefined,
             gates: derived,
             after: forkOf === undefined ? normalizedList(values.after, "after", contractId) : undefined,
         };
     });
 }
 /**
- * One Contract bind. `omittedMarkdownTarget` is the internal composition input an edge
- * supplies for a Markdown bind whose caller omitted the target: the public package-root
- * composition leaves it targetless, while the CLI names the invocation branch.
+ * One Contract bind. An omitted Markdown target names the current branch of the caller's explicit
+ * Repo worktree coordinate, `null` is deliberately targetless, and a string is that literal target.
  */
-export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition(), omittedMarkdownTarget = { kind: "targetless" }) {
+export async function bindKeiyaku(input, createHandle, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
     const prepared = bindInput(input, composition);
     const hooks = derivedHooks(composition);
     const { forkOf, scope, document, target, actor } = prepared;
@@ -84,7 +89,7 @@ export async function bindKeiyaku(input, createHandle, execution = localExecutio
                     }
                     if (document === undefined)
                         throw new Error("Markdown bind requires its prepared document");
-                    return await markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget);
+                    return await markdownBind(prepared, document, hooks, scope, channel, accumulator, handle);
                 })();
                 return completed;
             }, (error) => {
@@ -109,19 +114,16 @@ export async function bindKeiyaku(input, createHandle, execution = localExecutio
         throw projected.error;
     return projected.outcome;
 }
-function bindValue(keiyaku, region, warnings, workspace, appointmentLag) {
-    const base = {
+function bindValue(keiyaku, region, warnings) {
+    return {
         keiyaku,
-        ...(workspace === undefined ? {} : { workspace }),
         ...(warnings.length === 0 ? {} : { warnings }),
         ...region,
     };
-    void appointmentLag;
-    return base;
 }
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
 async function bindComplete(accumulator, id, scope, channel, leading, hooks, value) {
-    retainAdmission(accumulator, id, leading, false);
+    retainAdmission(accumulator, id, leading);
     await reconcileAffectedContracts(accumulator, id, scope, channel, hooks);
     try {
         const appointment = await readManagedWorktreeAppointment(scope, id);
@@ -136,15 +138,15 @@ async function bindComplete(accumulator, id, scope, channel, leading, hooks, val
         accumulator.recordStop(executionStop(id, "reconciliation", error, scope.signal));
     }
     const built = { ...(await value()), ...accumulator.conclusions(id) };
-    accumulator.extendConclusions(id, conclusions(built));
+    accumulator.extendConclusions(id, built);
     return built;
 }
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
-async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget) {
-    const { task, target, actor, gates, after } = prepared;
+async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle) {
+    const { debt, target, actor, gates, after } = prepared;
     if (gates === undefined || after === undefined)
         throw new Error("Markdown bind requires prepared terms");
-    const targetSelection = target !== undefined ? { kind: "explicit", target } : omittedMarkdownTarget;
+    const targetSelection = bindTargetSelection(target);
     const admission = await prepareMarkdownBind({
         scope,
         channel,
@@ -154,7 +156,7 @@ async function markdownBind(prepared, document, hooks, scope, channel, accumulat
         after,
         workspace: "worktree",
         targetSelection,
-        ...(task === undefined ? {} : { task }),
+        ...(debt === undefined ? {} : { debt }),
         ...actor,
     });
     const leading = admission.admission === null ? admission.result : admission.admission.result;

package/build/src/library/contract-execution.js

@@ -16,10 +16,10 @@ import { admitDeliveryOperation } from "../protocol/deliver.js";
 import { withScopeAbortSignal, } from "../protocol/operations.js";
 import { executionStop, isOperationalFailure, isOperationalStop, } from "../protocol/progress.js";
 import { admitReviewOperation } from "../protocol/review.js";
-import { releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection } from "../settlement/holder.js";
+import { releaseDebtHolder, releaseDebtHolderWithFence, debtHolderObservationSelection } from "../settlement/holder.js";
 import { continueDeliveredDependents } from "./continuation.js";
 import { requestForwardedContractLive } from "./contract-operations.js";
-import { acceptedOutcome, admissionOf, conclusions, expected, retainAdmission } from "./contract-outcomes.js";
+import { acceptedOutcome, expected, retainAdmission } from "./contract-outcomes.js";
 import { derivedContractPolicy, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
 import { deliveryForContract } from "./delivery.js";
 import { actorOption, contractTerms, documentDerivation, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
@@ -66,7 +66,7 @@ export class ContractExecution {
         });
         let changedSections;
         return await this.local("amend", async (accumulator, channel, scope) => {
-            const admission = admissionOf(await amendOperation({
+            const admission = await amendOperation({
                 scope,
                 channel,
                 contractId: this.id,
@@ -87,20 +87,18 @@ export class ContractExecution {
                         : contractTerms(amended, gates ?? source.gates, prerequisites ?? source.after);
                     return { terms, verification: documentDerivation(amended, terms.gates, this.id).verification };
                 },
-            }));
+            });
             if (admission.kind !== "accepted")
                 return expected(this.id, admission);
-            const accepted = admission.accepted;
-            const changes = changedAmendTerms(accepted.value.source, accepted.value.terms);
-            const diff = documentDiff("before", "after", accepted.value.source.document.bytes, accepted.value.terms.document.bytes);
+            const changes = changedAmendTerms(admission.value.source, admission.value.terms);
+            const diff = documentDiff("before", "after", admission.value.source.document.bytes, admission.value.terms.document.bytes);
             accumulator.extendConclusions(this.id, { documentDiff: diff, changes });
-            const region = await observeChangedRegion(scope, this.id, changedSections, decodeContractDocument(accepted.value.terms.document.bytes).region);
+            const region = await observeChangedRegion(scope, this.id, changedSections, decodeContractDocument(admission.value.terms.document.bytes).region);
             const value = await this.conclude(accumulator, {
                 scope,
                 channel,
-                leading: accepted,
+                leading: admission,
                 hooks,
-                verificationResidueRecorded: false,
                 value: () => ({
                     documentDiff: diff,
                     changes,
@@ -247,27 +245,26 @@ export class ContractExecution {
         });
         const hooks = derivedHooks(this.composition);
         return await this.local("abandon", async (accumulator, channel, scope) => {
-            const admission = admissionOf((await releaseTaskHolderWithFence(scope, channel, this.id, () => abandonOperation({
+            const admission = (await releaseDebtHolderWithFence(scope, channel, this.id, () => abandonOperation({
                 scope,
                 channel,
                 contractId: this.id,
                 ...actor,
                 ...(note === undefined ? {} : { note }),
-                observationSelection: taskHolderObservationSelection(),
+                observationSelection: debtHolderObservationSelection(),
                 progress: accumulator,
                 decorateOffer: async ({ observation, contractId: owner }) => {
-                    const companion = await releaseTaskHolder(channel, observation, owner);
+                    const companion = await releaseDebtHolder(channel, observation, owner);
                     return companion === null ? [] : [companion];
                 },
-            }))).result);
+            }))).result;
             if (admission.kind !== "accepted")
                 return expected(this.id, admission);
             await this.conclude(accumulator, {
                 scope,
                 channel,
-                leading: admission.accepted,
+                leading: admission,
                 hooks,
-                verificationResidueRecorded: false,
                 value: () => ({}),
             });
             return acceptedOutcome("abandon", this.id, accumulator, undefined);
@@ -283,22 +280,21 @@ export class ContractExecution {
         });
         const hooks = derivedHooks(this.composition);
         return await this.local("arc", async (accumulator, channel, scope) => {
-            const admission = admissionOf(await arcOperation({
+            const admission = await arcOperation({
                 scope,
                 channel,
                 contractId: this.id,
                 ...actor,
                 chapter,
                 progress: accumulator,
-            }));
+            });
             if (admission.kind !== "accepted")
                 return expected(this.id, admission);
             await this.conclude(accumulator, {
                 scope,
                 channel,
-                leading: admission.accepted,
+                leading: admission,
                 hooks,
-                verificationResidueRecorded: false,
                 value: () => ({}),
             });
             return acceptedOutcome("arc", this.id, accumulator, undefined);
@@ -327,7 +323,7 @@ export class ContractExecution {
             });
         const { hooks, requireBranchesToBeUpToDate } = derivedContractPolicy(this.composition);
         return await this.local("audit", async (accumulator, localChannel, scope) => {
-            const admission = admissionOf(await auditOperation({
+            const admission = await auditOperation({
                 scope,
                 channel: localChannel,
                 progress: accumulator,
@@ -338,15 +334,14 @@ export class ContractExecution {
                 requireBranchesToBeUpToDate,
                 ...(signal === undefined ? {} : { signal }),
                 ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
-            }));
+            });
             if (admission.kind !== "accepted")
                 return expected(this.id, admission);
             const report = await this.conclude(accumulator, {
                 scope,
                 channel: localChannel,
-                leading: admission.accepted,
+                leading: admission,
                 hooks,
-                verificationResidueRecorded: false,
                 value: (value) => value,
             });
             return acceptedOutcome("audit", this.id, accumulator, report);
@@ -380,9 +375,9 @@ export class ContractExecution {
         return projected.outcome;
     }
     async conclude(accumulator, input) {
-        retainAdmission(accumulator, this.id, input.leading, input.verificationResidueRecorded);
+        retainAdmission(accumulator, this.id, input.leading);
         const value = input.value(input.leading.value);
-        accumulator.extendConclusions(this.id, conclusions(value));
+        accumulator.extendConclusions(this.id, value);
         await reconcileAffectedContracts(accumulator, this.id, input.scope, input.channel, input.hooks);
         return value;
     }

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

@@ -41,17 +41,6 @@ export type BindResult = BindOutcome;
 type AcceptedIntent<Value> = Extract<IntentOutcome<Value>, {
     kind: "accepted";
 }>;
-type Admission<Value, Refusal> = Readonly<{
-    kind: "accepted";
-    accepted: AcceptedIntent<Value>;
-}> | Readonly<{
-    kind: "refused";
-    refusal: Refusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: IntentRetry;
-}>;
-export declare function admissionOf<Value, Refusal>(outcome: IntentOutcome<Value, Refusal>): Admission<Value, Refusal>;
 /** The refused/retry arms are value-agnostic, so every operation can return them unchanged. */
 type ExpectedProjection<Refusal> = Readonly<{
     kind: "refused";
@@ -62,10 +51,9 @@ type ExpectedProjection<Refusal> = Readonly<{
     contract?: ContractId;
     reason: IntentRetry;
 }>;
-export declare function expected<Refusal>(contract: ContractId | undefined, admission: Exclude<Admission<unknown, Refusal>, {
+export declare function expected<Refusal>(contract: ContractId | undefined, admission: Exclude<IntentOutcome<unknown, Refusal>, {
     kind: "accepted";
 }>): ExpectedProjection<Refusal>;
 export declare function acceptedOutcome<Operation extends ContractVerb, Value>(operation: Operation, contract: ContractId, accumulator: InvocationAccumulator, value: Value): OutcomeProjection<Operation, Value, never>;
-export declare function conclusions(value: object): Readonly<Record<string, unknown>>;
-export declare function retainAdmission<Value>(accumulator: InvocationAccumulator, contract: ContractId, leading: AcceptedIntent<Value>, verificationResidueRecorded: boolean): void;
+export declare function retainAdmission<Value>(accumulator: InvocationAccumulator, contract: ContractId, leading: AcceptedIntent<Value>): void;
 export {};

package/build/src/library/contract-outcomes.js

@@ -1,10 +1,3 @@
-export function admissionOf(outcome) {
-    if (outcome.kind === "accepted")
-        return { kind: "accepted", accepted: outcome };
-    return outcome.kind === "refused"
-        ? { kind: "refused", refusal: outcome.refusal }
-        : { kind: "retry", reason: outcome.reason };
-}
 export function expected(contract, admission) {
     return admission.kind === "refused"
         ? {
@@ -21,12 +14,8 @@ export function acceptedOutcome(operation, contract, accumulator, value) {
         throw new Error("missing leading admission receipt");
     return { kind: "accepted", contract, head, value };
 }
-export function conclusions(value) {
-    return value;
-}
-export function retainAdmission(accumulator, contract, leading, verificationResidueRecorded) {
+export function retainAdmission(accumulator, contract, leading) {
     accumulator.recordPublication(contract, leading.head, leading.facts);
     accumulator.recordResidue(contract, leading);
-    if (!verificationResidueRecorded)
-        accumulator.recordVerification(contract, undefined, leading);
+    accumulator.recordVerification(contract, undefined, leading);
 }

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

@@ -2,7 +2,7 @@ import type { AttestationData, ContractId, JournalEntry, SnapshotId } from "../c
 import type { Dispatch } from "../dispatch/index.js";
 import type { ContractBoard, ContractRow } from "../protocol/read/status.js";
 import type { Settings } from "../settings.js";
-import type { TaskId } from "../task/identity.js";
+import type { DebtId } from "../debt/identity.js";
 import type { Repo } from "./repo.js";
 /** Public gate words remain ordinary strings; private policy interprets them. */
 export type Gate = string;
@@ -25,8 +25,9 @@ export type ContractHistory = Readonly<{
 type MarkdownBindInput = Readonly<{
     repo: Repo;
     markdown: string;
-    task?: TaskId;
-    target?: string;
+    debt?: DebtId;
+    /** A literal target branch; `null` is deliberately targetless; omitted is the Repo worktree's current branch. */
+    target?: string | null;
     workspace?: "worktree";
     actor?: string;
     after?: readonly ContractId[];
@@ -35,7 +36,8 @@ type MarkdownBindInput = Readonly<{
 type ForkBindInput = Readonly<{
     repo: Repo;
     forkOf: ContractId;
-    target?: string;
+    /** A literal target branch; `null` clears the source target; omitted inherits it. */
+    target?: string | null;
     workspace?: "worktree";
     actor?: string;
 }>;
@@ -72,6 +74,38 @@ export type KeiyakuSelectInput = Readonly<{
     repo: Repo;
     id: ContractId;
 }>;
+export type ContractResolveInput = Readonly<{
+    repo: Repo;
+    selector?: string;
+    cwd?: string;
+}>;
+export type ContractSelectorRefusal = Readonly<{
+    kind: "invalid-selector";
+    selector: string;
+    diagnostic: string;
+}> | Readonly<{
+    kind: "redundant-short-selector";
+    selector: string;
+}> | Readonly<{
+    kind: "unknown-short-selector";
+    selector: string;
+}> | Readonly<{
+    kind: "ambiguous-selector";
+    selector: string;
+}> | Readonly<{
+    kind: "ambiguous-selector";
+    cwd: string;
+}> | Readonly<{
+    kind: "no-contextual-match";
+    cwd: string;
+}>;
+export type ContractResolution = Readonly<{
+    kind: "resolved";
+    id: ContractId;
+}> | Readonly<{
+    kind: "refused";
+    refusal: ContractSelectorRefusal;
+}>;
 export type ReviewInput = ActorOptions & Readonly<{
     verdict: AttestationData["verdict"];
     summary?: string;

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

@@ -544,8 +544,6 @@ type HandleType<T extends object> = Readonly<{
     [Symbol.hasInstance](value: unknown): boolean;
 }>;
 export declare const Delivery: HandleType<DeliveryHandle>;
-export declare function deliveryHandle(delivery: DeliveryValue, readDiff: () => Promise<string | null>): Delivery & DeliveryValue;
-export declare function deliveryHandle(delivery: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy"> & Partial<DeliveryValue>, readDiff: () => Promise<string | null>): Delivery;
 export declare function deliveryForContract(scope: RepositoryScope, delivery: DeliveryValue): Delivery & DeliveryValue;
 export declare function deliveryForContract(scope: RepositoryScope, delivery: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">): Delivery;
 export {};

package/build/src/library/delivery.js

@@ -30,13 +30,10 @@ export const Delivery = Object.freeze({
     prototype: DeliveryHandle.prototype,
     [Symbol.hasInstance]: (value) => value instanceof DeliveryHandle,
 });
-export function deliveryHandle(delivery, readDiff) {
-    return new DeliveryHandle(delivery, readDiff, delivery);
-}
 export function deliveryForContract(scope, delivery) {
-    return deliveryHandle(delivery, () => deliveryDiffOperation({
+    return new DeliveryHandle(delivery, () => deliveryDiffOperation({
         scope,
         integrationPredecessor: delivery.integration.predecessor,
         integrationSnapshot: delivery.integration.snapshot,
-    }));
+    }), delivery);
 }

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

@@ -1,13 +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 DebtId } from "../debt/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, allowed?: readonly string[]): Record<string, unknown>;
-export declare function taskOption(value: unknown): TaskId | undefined;
+export declare function debtOption(value: unknown): DebtId | 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

@@ -3,7 +3,7 @@ import { decodeContractDocument } from "../body/decode.js";
 import { validated } from "./outcome.js";
 import { verificationDefinition } from "../body/decode.js";
 import { actorId } from "../core/facts/types.js";
-import { parseTaskId } from "../task/identity.js";
+import { parseDebtId } from "../debt/identity.js";
 import { prepareVerificationDeclaration } from "../verification/declaration.js";
 export function actorOption(actor) {
     if (actor === undefined)
@@ -32,16 +32,16 @@ export function requireInput(value, label, allowed) {
     }
     return value;
 }
-export function taskOption(value) {
+export function debtOption(value) {
     if (value === undefined)
         return undefined;
     if (typeof value !== "string")
-        throw new TypeError("task must be a TaskId");
+        throw new TypeError("debt must be a DebtId");
     try {
-        parseTaskId(value);
+        parseDebtId(value);
     }
     catch (error) {
-        throw new TypeError(error instanceof Error ? error.message : "task must be a TaskId");
+        throw new TypeError(error instanceof Error ? error.message : "debt must be a DebtId");
     }
     return value;
 }

package/build/src/library/invocation.js

@@ -27,12 +27,12 @@ export class InvocationAccumulator {
         this.observer = observer;
     }
     beginReset(world) {
-        this.resetState = { world, removed: { refs: 0, worktrees: 0, tasks: 0 } };
+        this.resetState = { world, removed: { refs: 0, worktrees: 0, debts: 0 } };
     }
     recordResetRemoved(counts) {
         if (this.resetState === undefined)
             throw new Error("reset progress requires its World");
-        for (const key of ["refs", "worktrees", "tasks"])
+        for (const key of ["refs", "worktrees", "debts"])
             this.resetState.removed[key] += counts[key] ?? 0;
     }
     observe(event) {

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

@@ -32,11 +32,6 @@ export declare class Keiyaku {
     abandon(input?: AbandonInput): Promise<AbandonOutcome>;
     arc(input: ArcInput): Promise<ArcOutcome>;
     audit(input?: AuditInput, options?: MutationObservation): Promise<AuditOutcome>;
-    /**
-     * Reads answer with a value or `null` for legitimate absence. Corrupt authority stays exceptional
-     * and keeps its original native cause instead of being disguised as a raw native exception.
-     */
-    private read;
 }
 /** Internal constructor capability; callers select a Contract through Keiyaku.with. */
 export declare function createKeiyakuHandle(id: ContractId, scope: RepositoryScope, execution: ExecutionContext, composition: LocalContractCompositionCapture): Keiyaku;

package/build/src/library/keiyaku.js

@@ -7,7 +7,8 @@ import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { contractObservationOperation, deliveryOperation, stateOperation, } from "../protocol/operations.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
-import { composeContractLibrary, readContractValue } from "./contract-composition.js";
+import { composeContractLibrary } from "./contract-composition.js";
+import { readContractValue } from "./outcome.js";
 import { ContractExecution } from "./contract-execution.js";
 import { deliveryForContract } from "./delivery.js";
 const KEIYAKU_HANDLE = Symbol("Keiyaku handle");
@@ -41,10 +42,10 @@ export class Keiyaku {
         return { contract: this.id };
     }
     async state() {
-        return await this.read(() => withGitDecodeChannel(this.scope, (channel) => stateOperation({ scope: this.scope, channel, contractId: this.id })));
+        return await readContractValue(() => withGitDecodeChannel(this.scope, (channel) => stateOperation({ scope: this.scope, channel, contractId: this.id })));
     }
     async history() {
-        return await this.read(() => withGitDecodeChannel(this.scope, (channel) => withGitReadObservation(this.scope, channel, async (observation) => {
+        return await readContractValue(() => withGitDecodeChannel(this.scope, (channel) => withGitReadObservation(this.scope, channel, async (observation) => {
             const [journals, dispatches] = await Promise.all([
                 observeContractsForAdmissionInObservationAt(observation, [this.id]),
                 readDispatchesAt(observation),
@@ -84,7 +85,7 @@ export class Keiyaku {
         })));
     }
     async guidance() {
-        return await this.read(() => withGitDecodeChannel(this.scope, async (channel) => {
+        return await readContractValue(() => withGitDecodeChannel(this.scope, async (channel) => {
             const observed = await contractObservationOperation({ scope: this.scope, channel, contractId: this.id });
             if (observed.kind === "missing")
                 return null;
@@ -93,7 +94,7 @@ export class Keiyaku {
         }));
     }
     async delivery() {
-        const delivery = await this.read(() => withGitDecodeChannel(this.scope, (channel) => deliveryOperation({ scope: this.scope, channel, contractId: this.id })));
+        const delivery = await readContractValue(() => withGitDecodeChannel(this.scope, (channel) => deliveryOperation({ scope: this.scope, channel, contractId: this.id })));
         return delivery === null ? null : deliveryForContract(this.scope, delivery);
     }
     async amend(input) {
@@ -114,13 +115,6 @@ export class Keiyaku {
     async audit(input, options) {
         return await this.operations.audit(input, options);
     }
-    /**
-     * Reads answer with a value or `null` for legitimate absence. Corrupt authority stays exceptional
-     * and keeps its original native cause instead of being disguised as a raw native exception.
-     */
-    async read(operation) {
-        return await readContractValue(operation);
-    }
 }
 /** Internal constructor capability; callers select a Contract through Keiyaku.with. */
 export function createKeiyakuHandle(id, scope, execution, composition) {

package/build/src/library/nuke.js

@@ -4,7 +4,7 @@ import { resolve } from "node:path";
 import { AkumaResetStopError, stopAkuma } from "../akuma/nuke.js";
 import { GitResetStopError, nukeGit } from "../git/nuke.js";
 import { isOperationalFailure } from "../protocol/progress.js";
-import { nukeTask } from "../task/operations.js";
+import { nukeDebt } from "../debt/operations.js";
 import { World } from "../world.js";
 import { requireInput, requireMarkdown } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
@@ -73,8 +73,8 @@ export async function nukeKeiyaku(input, gitOptions) {
                             diagnostic: result.closeLag.diagnostic,
                         });
                 }),
-                runOwner("task", async () => {
-                    await nukeTask(world, { onRemoved: (tasks) => accumulator.recordResetRemoved({ tasks }) });
+                runOwner("debt", async () => {
+                    await nukeDebt(world, { onRemoved: (debts) => accumulator.recordResetRemoved({ debts }) });
                 }),
             ]);
             await runOwner("world", () => removeEmptyWorldMarker(world));