@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/akuma/requests.d.ts

@@ -1,49 +1,21 @@
-import { type CallRequestClaim, type DeliverRequestClaim, type ForwardedDeliveryReference, type ForwardedReviewReference, type KillRequestClaim, type ReviewRequestClaim, type TellRequestClaim, type UpstreamRequestOutcome, type WaitRequestClaim } from "./request-wire.js";
-import { type TaskMutationRequest } from "../task/mutation.js";
-export type { UpstreamRequestOutcome } from "./request-wire.js";
-export declare class AkumaBodyRequestError extends Error {
-    readonly outcome: "refused" | "voided";
-    readonly diagnostic: string;
-    readonly kind = "akuma-body-request";
-    constructor(outcome: "refused" | "voided", diagnostic: string);
-}
-export declare function injectedBodyRequests(): string | null;
-export declare function requestBodyCall(input: Omit<CallRequestClaim, "action"> & Readonly<{
+export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
+export type ExecutionChannel = Readonly<{
+    kind: "local";
+}> | Readonly<{
+    kind: "body-request";
     directory: string;
-}>): Promise<import("./identity.js").AkuId>;
-export declare function requestBodyTask(input: Readonly<{
-    directory: string;
-    world: string;
-    request: TaskMutationRequest;
-    id?: string;
-}>): Promise<unknown>;
-export declare function requestBodyWait(input: Omit<WaitRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyTell(input: Omit<TellRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyKill(input: Omit<KillRequestClaim, "action" | "id"> & Readonly<{
-    directory: string;
-    id?: string;
-}>): Promise<UpstreamRequestOutcome>;
-type ContractRequestInput<T extends DeliverRequestClaim | ReviewRequestClaim> = Omit<T, "action" | "id"> & Readonly<{
-    directory: string;
-    signal?: AbortSignal;
 }>;
-type BodyDeliverInput = ContractRequestInput<DeliverRequestClaim>;
-export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
-    id?: never;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyDeliver(input: BodyDeliverInput & Readonly<{
-    id: string;
-}>): Promise<UpstreamRequestOutcome | ForwardedDeliveryReference>;
-type BodyReviewInput = ContractRequestInput<ReviewRequestClaim>;
-export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
-    id?: never;
-}>): Promise<UpstreamRequestOutcome>;
-export declare function requestBodyReview(input: BodyReviewInput & Readonly<{
-    id: string;
-}>): Promise<UpstreamRequestOutcome | ForwardedReviewReference>;
+export type ExecutionContext = Readonly<{
+    channel: ExecutionChannel;
+}>;
+export type LibraryExecution = ExecutionContext;
+export declare function localExecutionContext(): ExecutionContext;
+export declare function bodyRequestExecutionContext(directory: unknown): ExecutionContext;
+/** Constructs the one direct-parent route a caller may explicitly compose. */
+export declare function bodyRequestExecution(input: Readonly<{
+    directory: string;
+}>): LibraryExecution;
+/** Normalizes the public carrier before a composition captures its immutable channel. */
+export declare function libraryExecution(value: unknown): LibraryExecution;
+export declare function libraryExecutionInput(input: unknown): LibraryExecution;
+export declare function executionChannel(context?: ExecutionContext): ExecutionChannel;

package/build/src/akuma/requests.js

@@ -1,120 +1,64 @@
-import { randomUUID } from "node:crypto";
-import { access, readFile } from "node:fs/promises";
-import { abortableDelay } from "./abort.js";
-import { AKUMA_REQUESTS_ENV } from "./provider.js";
-import { absolute, atomicJson, decodeReceipt, receiptPath, requestPath, requestPayload, } from "./request-wire.js";
-import { isTaskMutationAction } from "../task/mutation.js";
-const POLL_MS = 100;
-export class AkumaBodyRequestError extends Error {
-    outcome;
-    diagnostic;
-    kind = "akuma-body-request";
-    constructor(outcome, diagnostic) {
-        super(`Akuma body request ${outcome}: ${diagnostic}`);
-        this.outcome = outcome;
-        this.diagnostic = diagnostic;
-        this.name = "AkumaBodyRequestError";
-    }
-}
-export function injectedBodyRequests() {
-    const directory = process.env[AKUMA_REQUESTS_ENV];
-    if (directory === undefined)
-        return null;
-    if (!absolute(directory))
-        throw new Error(`${AKUMA_REQUESTS_ENV} must be an absolute normalized path`);
-    return directory;
+import { isAbsolute, resolve } from "node:path";
+export { AkumaBodyRequestError, requestBodyCommand } from "./request-rendezvous.js";
+const LOCAL_CHANNEL = Object.freeze({ kind: "local" });
+export function localExecutionContext() {
+    return Object.freeze({ channel: LOCAL_CHANNEL });
 }
-async function requestBody(input) {
-    input.signal?.throwIfAborted();
-    const transportId = randomUUID();
-    await atomicJson(requestPath(input.directory, transportId), {
-        id: input.claim.id,
-        action: input.claim.action,
-        payload: requestPayload(input.claim),
-    });
-    const path = receiptPath(input.directory, transportId);
-    for (;;) {
-        try {
-            const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);
-            if (receipt === null)
-                throw new Error(`Akuma body request ${input.claim.id} has an invalid receipt`);
-            if (receipt.state === "refused")
-                throw new AkumaBodyRequestError("refused", receipt.diagnostic);
-            if (receipt.state === "voided")
-                throw new AkumaBodyRequestError("voided", receipt.evidence);
-            return receipt;
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                throw error;
-        }
-        if (!(await access(input.directory).then(() => true, () => false))) {
-            throw new AkumaBodyRequestError("voided", "parent request channel closed before a receipt");
-        }
-        await abortableDelay(POLL_MS, input.signal);
+export function bodyRequestExecutionContext(directory) {
+    if (typeof directory !== "string" || !isAbsolute(directory) || resolve(directory) !== directory) {
+        throw new Error("AKUMA_REQUESTS must be an absolute normalized path");
     }
+    return Object.freeze({ channel: Object.freeze({ kind: "body-request", directory }) });
 }
-export async function requestBodyCall(input) {
-    const { directory, ...claim } = input;
-    const receipt = await requestBody({ directory, claim: { ...claim, action: "akuma.call" } });
-    if (receipt.action !== "akuma.call" || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${input.id} returned the wrong action`);
+function valueRecord(value, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
     }
-    return receipt.child;
+    return value;
 }
-async function requestUpstream(directory, claim, signal) {
-    const receipt = await requestBody({ directory, claim, ...(signal === undefined ? {} : { signal }) });
-    if (receipt.action === "akuma.call" || receipt.state !== "served" || !("outcome" in receipt)) {
-        throw new Error(`Akuma body request ${claim.id} returned the wrong action`);
+function closed(value, keys, label) {
+    for (const key of Object.keys(value)) {
+        if (!keys.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
     }
-    return receipt.outcome;
 }
-export async function requestBodyTask(input) {
-    const id = input.id ?? randomUUID();
-    const receipt = await requestBody({
-        directory: input.directory,
-        claim: { id, action: input.request.action, world: input.world, request: input.request },
-    });
-    if (!isTaskMutationAction(receipt.action) || receipt.action !== input.request.action || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${id} returned the wrong action`);
+/** Constructs the one direct-parent route a caller may explicitly compose. */
+export function bodyRequestExecution(input) {
+    const value = valueRecord(input, "body request execution input");
+    closed(value, ["directory"], "body request execution input");
+    if (typeof value.directory !== "string")
+        throw new TypeError("body request execution directory must be a string");
+    try {
+        return bodyRequestExecutionContext(value.directory);
+    }
+    catch (error) {
+        throw new TypeError(error instanceof Error ? error.message : String(error));
     }
-    if ("reference" in receipt)
-        return receipt.reference;
-    if (receipt.outcome.kind === "returned")
-        return receipt.outcome.result;
-    throw new Error(receipt.outcome.failure.kind === "failed"
-        ? receipt.outcome.failure.diagnostic
-        : "Akuma body request parent is not born");
-}
-export async function requestBodyWait(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.wait" });
-}
-export async function requestBodyTell(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.tell" });
-}
-export async function requestBodyKill(input) {
-    const { directory, id = randomUUID(), ...claim } = input;
-    return await requestUpstream(directory, { ...claim, id, action: "akuma.kill" });
 }
-async function requestContract(input, action) {
-    const { directory, id = randomUUID(), signal, ...claim } = input;
-    const receipt = await requestBody({
-        directory,
-        claim: { ...claim, id, action },
-        ...(signal === undefined ? {} : { signal }),
-    });
-    if (receipt.action !== action || receipt.state !== "served") {
-        throw new Error(`Akuma body request ${id} returned the wrong action`);
+/** Normalizes the public carrier before a composition captures its immutable channel. */
+export function libraryExecution(value) {
+    const context = valueRecord(value, "execution");
+    closed(context, ["channel"], "execution");
+    const channel = valueRecord(context.channel, "execution channel");
+    if (channel.kind === "local") {
+        closed(channel, ["kind"], "execution channel");
+        return localExecutionContext();
+    }
+    if (channel.kind === "body-request") {
+        closed(channel, ["directory", "kind"], "execution channel");
+        if (typeof channel.directory !== "string")
+            throw new TypeError("execution channel directory must be a string");
+        return bodyRequestExecution({ directory: channel.directory });
     }
-    return "reference" in receipt
-        ? receipt.reference
-        : receipt.outcome;
+    throw new TypeError("execution channel must be local or body-request");
 }
-export async function requestBodyDeliver(input) {
-    return await requestContract(input, "contract.deliver");
+export function libraryExecutionInput(input) {
+    const value = valueRecord(input, "Keiyaku.withExecution input");
+    closed(value, ["execution"], "Keiyaku.withExecution input");
+    if (value.execution === undefined)
+        throw new TypeError("Keiyaku.withExecution input requires execution");
+    return libraryExecution(value.execution);
 }
-export async function requestBodyReview(input) {
-    return await requestContract(input, "contract.review");
+export function executionChannel(context) {
+    return context?.channel ?? LOCAL_CHANNEL;
 }

package/build/src/akuma/turn-drive.d.ts

@@ -1,7 +1,8 @@
 import { type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
-import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.js";
+import type { AkumaCallRequestChildLaunch } from "./call-request.js";
+import type { ErasedRequestCommand } from "./request-wire.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
@@ -25,8 +26,9 @@ export type DriveTurnInput = Readonly<{
     call?: string;
     launchTells: readonly TellFact[];
     supervisor: BodySupervisor;
-    runtimeSpawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
-    upstream?: UpstreamExecutionPort;
+    runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    upstream?: unknown;
+    commands: Readonly<Record<string, ErasedRequestCommand>>;
     now(): string;
 }>;
 export declare function driveTurn(input: DriveTurnInput): Promise<(DrivenTurn & Readonly<{

package/build/src/akuma/turn-drive.js

@@ -1,6 +1,7 @@
 import { abortableDelay } from "./abort.js";
+/* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
 import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
-import { encodeAgentEvent } from "./provider.js";
+import { encodeAgentEvent, } from "./provider.js";
 import { BodyRequestPump } from "./request-serve.js";
 import { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function serializeEffects() {
@@ -79,6 +80,7 @@ async function startTurnDrive(input) {
         now: input.now,
         spawn: input.runtimeSpawn,
         ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
+        commands: input.commands,
         signal: input.supervisor.signal,
     });
     const driveController = new AbortController();
@@ -101,14 +103,15 @@ async function startTurnDrive(input) {
         signal: driveController.signal,
         requests: { dir: requests.directory },
     };
-    const setup = session === undefined
+    const attempt = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
         : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
+    const custodyFailure = observeFailure(attempt.closed);
     try {
-        const selected = await Promise.race([setup, requests.failure]);
+        const selected = await Promise.race([attempt.result, requests.failure, custodyFailure]);
         if (input.supervisor.signal.aborted) {
             try {
-                const retirement = await retireProviderCustody(input, turn.sequence, selected);
+                const retirement = await retireProviderCustody(input, turn.sequence, attempt);
                 await requests.close();
                 if (retirement.kind === "hung")
                     return retirement;
@@ -129,6 +132,8 @@ async function startTurnDrive(input) {
         void selected.completion.then(() => requests.stopAdmission(), () => undefined);
         return {
             turnSequence: turn.sequence,
+            attempt,
+            custodyFailure,
             drive: selected,
             requests,
             cwd,
@@ -138,21 +143,39 @@ async function startTurnDrive(input) {
         };
     }
     catch (error) {
+        const retirement = await retireProviderCustody(input, turn.sequence, attempt);
+        if (retirement.kind === "hung") {
+            try {
+                await requests.close();
+            }
+            finally {
+                input.supervisor.signal.removeEventListener("abort", cancelDrive);
+            }
+            return retirement;
+        }
         return await failedTurnSetup(input, turn.sequence, requests, cancelDrive, error);
     }
 }
-async function retireProviderCustody(input, turnSequence, drive) {
+async function retireProviderCustody(input, turnSequence, attempt) {
     const dispose = async (operation) => await Promise.race([
-        operation().then(() => ({ kind: "retired" }), (error) => ({ kind: "held", error })),
+        operation().then(async () => {
+            try {
+                await attempt.closed;
+                return { kind: "retired" };
+            }
+            catch (error) {
+                return { kind: "held", error };
+            }
+        }, (error) => ({ kind: "held", error })),
         abortableDelay(CONTROL_RESPONSE_MS).then(() => ({
             kind: "held",
             error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
         })),
     ]);
-    let outcome = await dispose(drive.abort);
+    let outcome = await dispose(attempt.abort);
     if (outcome.kind === "retired")
         return outcome;
-    outcome = await dispose(drive.forceDispose);
+    outcome = await dispose(attempt.forceDispose);
     if (outcome.kind === "retired")
         return outcome;
     if (await heartExists(input.paths)) {
@@ -191,8 +214,11 @@ function pumpReceipts(writers) {
         }
     })();
 }
+function observeFailure(settlement) {
+    return settlement.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+}
 function observeReceiptFailure(receiptPump) {
-    return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+    return observeFailure(receiptPump);
 }
 function observeCompletionFailure(drive) {
     return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
@@ -226,7 +252,7 @@ async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
 }
 async function stopActiveDrive(input, active) {
     try {
-        const retirement = await retireProviderCustody(input, active.turnSequence, active.drive);
+        const retirement = await retireProviderCustody(input, active.turnSequence, active.attempt);
         await active.requests.close();
         return retirement;
     }
@@ -285,6 +311,7 @@ async function consumeTurnDrive(input, active) {
                 receiptFailure,
                 requests.failure,
                 completionFailure,
+                active.custodyFailure,
             ]);
             if (next.kind === "completion-failed") {
                 requests.stopAdmission();
@@ -308,6 +335,7 @@ async function consumeTurnDrive(input, active) {
             pending = iterator.next();
         }
         const result = await drive.completion;
+        await active.attempt.closed;
         if (tellPump !== null)
             await tellPump;
         await writeWitness.drain();
@@ -320,7 +348,7 @@ async function consumeTurnDrive(input, active) {
             const retirement = await stopActiveDrive(input, active);
             return retirement.kind === "hung" ? retirement : { kind: "stopped" };
         }
-        const retirement = await retireProviderCustody(input, turnSequence, drive);
+        const retirement = await retireProviderCustody(input, turnSequence, active.attempt);
         try {
             await requests.close();
         }

package/build/src/akuma-body.d.ts

@@ -1,8 +1,13 @@
 import { type BodyLaunch } from "./akuma/body.js";
-import type { UpstreamExecutionPort } from "./akuma/request-serve.js";
+import { type WorldRoot } from "./world.js";
+import { type FleetRequestPort } from "./library/fleet.js";
+import { type ContractRequestPort } from "./library/contract-operations.js";
+import { type TaskMutationRequestPort } from "./task/mutation.js";
 type BodyProcessConfiguration = Readonly<{
     home?: string;
     gitPath?: string;
 }>;
-export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): UpstreamExecutionPort;
+export declare function upstreamFor(launch: BodyLaunch, processConfiguration: BodyProcessConfiguration): Promise<FleetRequestPort & ContractRequestPort & TaskMutationRequestPort & Readonly<{
+    launchWorld(): WorldRoot;
+}>>;
 export {};

package/build/src/akuma-body.js

@@ -1,47 +1,45 @@
 import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
+import { akumaCallRequestCommands } from "./akuma/call-request.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
+import { World } from "./world.js";
 import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./library/fleet.js";
+import { fleetRequestCommands } from "./library/fleet.js";
 import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom } from "./library/configuration.js";
-import { executeForwardedDeliver, executeForwardedReview } from "./library/contract.js";
+import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
 import { Repo } from "./library/repo.js";
 import { settings } from "./settings.js";
-import { executeTaskMutation } from "./task/mutation.js";
-export function upstreamFor(launch, processConfiguration) {
-    const path = worldRootForAkumaPaths(launch.paths);
+import { executeTaskMutation, taskMutationRequestCommands } from "./task/mutation.js";
+async function contractDependencies(repoRoot, processConfiguration) {
+    const repo = await Repo.at({
+        path: repoRoot,
+        ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+    });
+    if (repo.root !== repoRoot)
+        throw new TypeError("forwarded Contract repoRoot must equal the canonical primary worktree");
+    const world = await World.prove(repo.root);
+    const configuration = await settings({
+        root: world,
+        ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+    });
+    return [repo, configuration];
+}
+function contractUpstream(processConfiguration) {
     return {
-        wait: async (input) => await executeWaitAkuma({
-            path,
-            ids: input.targets,
-            completion: input.completion,
-            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-            signal: input.signal,
-        }),
-        tell: async (input) => await executeTellAkuma({
-            path,
-            id: input.target,
-            body: input.body,
-            tellId: input.tellId,
-            recordedAt: input.recordedAt,
-            signal: input.signal,
-        }),
-        kill: async (input) => {
-            const result = await executeKillAkuma({ path, ids: input.targets, signal: input.signal });
-            return {
-                result,
-                service: result.results.map(({ id, evidence }) => ({ id, evidence })),
-            };
+        audit: async (input) => {
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
+            return await executeForwardedAudit({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                includeDirty: input.includeDirty,
+                showDiff: input.showDiff,
+                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+                signal: input.signal,
+            });
         },
         deliver: async (input) => {
-            const [repo, configuration] = await Promise.all([
-                Repo.at({
-                    path: input.repoRoot,
-                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
-                }),
-                settings({
-                    root: input.repoRoot,
-                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
-                }),
-            ]);
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedDeliver({
                 repo,
                 contractId: input.contractId,
@@ -55,16 +53,7 @@ export function upstreamFor(launch, processConfiguration) {
             });
         },
         review: async (input) => {
-            const [repo, configuration] = await Promise.all([
-                Repo.at({
-                    path: input.repoRoot,
-                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
-                }),
-                settings({
-                    root: input.repoRoot,
-                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
-                }),
-            ]);
+            const [repo, configuration] = await contractDependencies(input.repoRoot, processConfiguration);
             return await executeForwardedReview({
                 repo,
                 contractId: input.contractId,
@@ -74,6 +63,32 @@ export function upstreamFor(launch, processConfiguration) {
                 hooks: worktreeHooksFrom({ settings: configuration }),
             });
         },
+    };
+}
+export async function upstreamFor(launch, processConfiguration) {
+    const world = await World.prove(worldRootForAkumaPaths(launch.paths));
+    return {
+        launchWorld: () => world,
+        ...contractUpstream(processConfiguration),
+        wait: async (input) => await executeWaitAkuma({
+            path: world,
+            ids: input.targets,
+            completion: input.completion,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            signal: input.signal,
+        }),
+        tell: async (input) => await executeTellAkuma({
+            path: world,
+            id: input.target,
+            body: input.body,
+            tellId: input.tellId,
+            recordedAt: input.recordedAt,
+            signal: input.signal,
+        }),
+        kill: async (input) => {
+            const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });
+            return result;
+        },
         task: async (input) => await executeTaskMutation({
             world: input.world,
             request: input.request,
@@ -95,5 +110,12 @@ const configuration = {
     ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
     ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
 };
-if ((await runAkumaBody(launch, upstreamFor(launch, configuration))) === "held")
+const upstream = await upstreamFor(launch, configuration);
+const commands = {
+    ...akumaCallRequestCommands(),
+    ...fleetRequestCommands(),
+    ...contractRequestCommands(),
+    ...taskMutationRequestCommands(),
+};
+if ((await runAkumaBody(launch, upstream, commands)) === "held")
     process.exitCode = LEASH_HELD_EXIT;

package/build/src/body/amend.js

@@ -22,10 +22,11 @@ function operationSections(document) {
         refusal("amend operations contain bytes outside H2 sections");
     }
     return sections(document).map((section) => {
-        const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(section.title.trim());
-        if (!match)
-            refusal(`invalid amend operation heading: ${section.title}`);
-        return { kind: match[1], target: match[2].trim(), section };
+        const title = section.title.trim();
+        const match = /^(Add|Update|Replace|Append|Remove):[ ]+(.+)$/.exec(title);
+        return match
+            ? { kind: match[1], target: match[2].trim(), section }
+            : { kind: "Set", target: title, section };
     });
 }
 function prose(document, section, label) {
@@ -112,7 +113,7 @@ function completeBody(body) {
         objective: body.objective,
         design: body.design,
         region: body.region,
-        criteria: body.criteria.filter((criterion) => criterion !== undefined),
+        criteria: body.criteria,
         verification: body.verification,
         extensions: body.extensions.filter((extension) => extension !== undefined),
     };
@@ -137,15 +138,6 @@ function alteredText(body, target, value) {
 }
 function applyRemove(body, operation, document) {
     requireEmpty(document, operation.section);
-    if (operation.target.startsWith("Criterion ")) {
-        const title = operation.target.slice("Criterion ".length);
-        const index = criterionIndex(body, title);
-        if (index < 0)
-            refusal(`unknown criterion '${title}'`);
-        body.criteria[index] = undefined;
-        body.criterionIndexes.delete(normalizeTitle(title));
-        return;
-    }
     const index = extensionIndex(body, operation.target);
     if (index < 0)
         refusal(`unknown extension '${operation.target}'`);
@@ -236,6 +228,13 @@ function applyReplace(body, operation, document) {
     const extension = body.extensions[index];
     body.extensions[index] = { ...extension, content: prose(document, operation.section, "extension") };
 }
+function applySet(body, operation, document) {
+    if (contractSectionName(operation.target) !== null || extensionIndex(body, operation.target) >= 0) {
+        applyReplace(body, operation, document);
+        return;
+    }
+    applyAdd(body, operation, document);
+}
 function applyOperation(body, operation, document) {
     switch (operation.kind) {
         case "Add":
@@ -253,13 +252,13 @@ function applyOperation(body, operation, document) {
         case "Remove":
             applyRemove(body, operation, document);
             return;
+        case "Set":
+            applySet(body, operation, document);
+            return;
     }
 }
 function operationKey(operation) {
-    const target = operation.target.startsWith("Criterion ")
-        ? `Criterion ${normalizeTitle(operation.target.slice("Criterion ".length))}`
-        : operation.target;
-    return `${operation.kind}:${target}`;
+    return `${operation.kind}:${operation.target}`;
 }
 function apply(source, current) {
     const document = parseToAST(source);
@@ -274,7 +273,7 @@ function apply(source, current) {
         if (seen.has(key))
             refusal(`duplicate amend operation '${key}'`);
         seen.add(key);
-        changed.add(normalizeTitle(operation.target.startsWith("Criterion ") ? "Criteria" : operation.target));
+        changed.add(normalizeTitle(operation.target));
         applyOperation(body, operation, document);
     }
     return { body: completeBody(body), changed };

package/build/src/cli/accepted.d.ts

@@ -1,6 +1,6 @@
 import { type AmendResult, type AuditReport, type BindResult, type ContractId, type Delivery, type MutationResult, type Review } from "../index.js";
 import type { AcceptedAbandonResult, AcceptedAmendResult, AcceptedArcResult, AcceptedAuditResult, AcceptedBindResult, AcceptedDeliverResult, AcceptedResult, AcceptedReviewResult, InvocationResult } from "./result.js";
-type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "effects" | "lags" | "settlement">;
+type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "lags" | "settlementLags" | "recoverySnapshot">;
 type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
     projectRefusal?: (refusal: unknown) => unknown;