@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/akuma/requests.js

@@ -1,13 +1,14 @@
 import { randomUUID } from "node:crypto";
 import { access, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, voidRequest, } from "./heart/index.js";
+import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
 import { parseAkuId, pathsForAkuId, archetypeName, worldRootForAkumaPaths, } from "./identity.js";
 import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
 import { abortableDelay } from "./abort.js";
 import { AKUMA_REQUESTS_ENV } from "./provider.js";
 import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
 import { resolveProviderExecution } from "./providers/index.js";
+import { decodeAllowedActions } from "./allowed.js";
 const POLL_MS = 25;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 export class AkumaBodyRequestError extends Error {
@@ -36,24 +37,13 @@ function exactKeys(value, expected) {
 function absolute(value) {
     return typeof value === "string" && isAbsolute(value) && resolve(value) === value;
 }
-function matchingConfinement(value, expected) {
-    const confinement = object(value);
-    if (confinement === null || confinement.kind !== expected.kind)
-        return false;
-    if (expected.kind === "unconfined")
-        return exactKeys(confinement, ["kind"]);
-    if (!exactKeys(confinement, ["kind", "writableRoots"]) || !Array.isArray(confinement.writableRoots))
-        return false;
-    return confinement.writableRoots.length === expected.writableRoots.length
-        && confinement.writableRoots.every((root, index) => root === expected.writableRoots[index]);
-}
 function decodeRecipe(value, cwd) {
     const recipe = object(value);
     if (recipe === null)
         return null;
     const expectedKeys = [
-        "confinement",
         ...(recipe.description === undefined ? [] : ["description"]),
+        "allowed",
         "options",
         "provider",
         ...(recipe.readonly === undefined ? [] : ["readonly"]),
@@ -72,10 +62,9 @@ function decodeRecipe(value, cwd) {
         if ((decodedOptions.readonly === true) !== (readonly !== undefined))
             return null;
         const confinement = adapter.confinement({ cwd, options: decodedOptions });
-        if (!matchingConfinement(recipe.confinement, confinement))
-            return null;
         return Object.freeze({
             ...(recipe.description === undefined ? {} : { description: recipe.description }),
+            allowed: decodeAllowedActions(recipe.allowed),
             provider,
             options: decodedOptions,
             ...(readonly === undefined ? {} : { readonly }),
@@ -86,52 +75,98 @@ function decodeRecipe(value, cwd) {
         return null;
     }
 }
-function decodeClaim(bytes, fileId) {
-    let decoded;
+function canonicalAkuId(value) {
+    if (typeof value !== "string")
+        return null;
     try {
-        decoded = JSON.parse(bytes);
+        const id = parseAkuId(value).id;
+        return id === value ? id : null;
     }
     catch {
         return null;
     }
-    const value = object(decoded);
-    if (value === null)
+}
+function canonicalTargets(value) {
+    if (!Array.isArray(value) || value.length === 0)
         return null;
+    const ids = [];
+    for (const item of value) {
+        const id = canonicalAkuId(item);
+        if (id === null)
+            return null;
+        if (ids.length > 0 && Buffer.compare(Buffer.from(ids.at(-1)), Buffer.from(id)) >= 0)
+            return null;
+        ids.push(id);
+    }
+    return ids;
+}
+function decodeCallClaim(id, payload) {
     const expected = [
         "archetype",
         "body",
-        ...(value.cwd === undefined ? [] : ["cwd"]),
-        "id",
+        ...(payload.cwd === undefined ? [] : ["cwd"]),
         "recipe",
         "world",
     ];
-    if (!exactKeys(value, expected))
+    if (!exactKeys(payload, expected)
+        || typeof payload.body !== "string"
+        || !absolute(payload.world))
         return null;
-    if (value.id !== fileId || typeof value.id !== "string" || !UUID.test(value.id))
-        return null;
-    if (typeof value.body !== "string" || !absolute(value.world))
-        return null;
-    if (value.cwd !== undefined && !absolute(value.cwd))
+    if (payload.cwd !== undefined && !absolute(payload.cwd))
         return null;
     try {
-        archetypeName(value.archetype);
+        archetypeName(payload.archetype);
     }
     catch {
         return null;
     }
-    const recipe = decodeRecipe(value.recipe, (value.cwd ?? value.world));
-    if (recipe === null)
+    return {
+        id,
+        action: "akuma.call",
+        world: payload.world,
+        archetype: payload.archetype,
+        body: payload.body,
+        recipe: payload.recipe,
+        ...(payload.cwd === undefined ? {} : { cwd: payload.cwd }),
+    };
+}
+function decodeWaitClaim(id, payload) {
+    const expected = [
+        "completion",
+        "targets",
+        ...(payload.timeoutMs === undefined ? [] : ["timeoutMs"]),
+    ];
+    const targets = canonicalTargets(payload.targets);
+    if (!exactKeys(payload, expected)
+        || targets === null
+        || (payload.completion !== "any" && payload.completion !== "all"))
+        return null;
+    if (payload.timeoutMs !== undefined
+        && (!Number.isSafeInteger(payload.timeoutMs) || payload.timeoutMs < 0))
         return null;
     return {
-        id: value.id,
-        world: value.world,
-        archetype: value.archetype,
-        body: value.body,
-        recipe,
-        ...(value.cwd === undefined ? {} : { cwd: value.cwd }),
+        id,
+        action: "akuma.wait",
+        targets,
+        completion: payload.completion,
+        ...(payload.timeoutMs === undefined ? {} : { timeoutMs: payload.timeoutMs }),
     };
 }
-function decodeReceipt(bytes, requestId) {
+function decodeTellClaim(id, payload) {
+    const target = canonicalAkuId(payload.target);
+    if (!exactKeys(payload, ["body", "target"])
+        || target === null
+        || typeof payload.body !== "string")
+        return null;
+    return { id, action: "akuma.tell", target, body: payload.body };
+}
+function decodeKillClaim(id, payload) {
+    const targets = canonicalTargets(payload.targets);
+    return exactKeys(payload, ["targets"]) && targets !== null
+        ? { id, action: "akuma.kill", targets }
+        : null;
+}
+function decodeClaim(bytes, fileId) {
     let decoded;
     try {
         decoded = JSON.parse(bytes);
@@ -140,23 +175,82 @@ function decodeReceipt(bytes, requestId) {
         return null;
     }
     const value = object(decoded);
-    if (value === null || value.id !== requestId)
+    if (value === null
+        || !exactKeys(value, ["action", "id", "payload"])
+        || value.id !== fileId
+        || typeof value.id !== "string"
+        || !UUID.test(value.id))
         return null;
-    if (value.state === "served" && exactKeys(value, ["child", "id", "state"])) {
-        try {
-            return { id: requestId, state: "served", child: parseAkuId(value.child).id };
-        }
-        catch {
-            return null;
-        }
+    const payload = object(value.payload);
+    if (payload === null)
+        return null;
+    if (value.action === "akuma.call")
+        return decodeCallClaim(value.id, payload);
+    if (value.action === "akuma.wait")
+        return decodeWaitClaim(value.id, payload);
+    if (value.action === "akuma.tell")
+        return decodeTellClaim(value.id, payload);
+    if (value.action === "akuma.kill")
+        return decodeKillClaim(value.id, payload);
+    return null;
+}
+function decodeUpstreamFailure(value) {
+    const failure = object(value);
+    if (failure === null)
+        return null;
+    if (failure.kind === "akuma-not-born" && exactKeys(failure, ["id", "kind"])) {
+        const id = canonicalAkuId(failure.id);
+        return id === null ? null : { kind: failure.kind, id };
+    }
+    if (failure.kind === "failed"
+        && exactKeys(failure, ["diagnostic", "kind"])
+        && typeof failure.diagnostic === "string") {
+        return { kind: failure.kind, diagnostic: failure.diagnostic };
+    }
+    return null;
+}
+function decodeUpstreamOutcome(value) {
+    const outcome = object(value);
+    if (outcome?.kind === "returned" && exactKeys(outcome, ["kind", "result"])) {
+        return { kind: outcome.kind, result: outcome.result };
+    }
+    if (outcome?.kind !== "failed" || !exactKeys(outcome, ["failure", "kind"]))
+        return null;
+    const failure = decodeUpstreamFailure(outcome.failure);
+    return failure === null ? null : { kind: outcome.kind, failure };
+}
+function decodeReceipt(bytes, requestId, action) {
+    let decoded;
+    try {
+        decoded = JSON.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+    const value = object(decoded);
+    if (value === null || value.id !== requestId || value.action !== action)
+        return null;
+    if (action === "akuma.call"
+        && value.state === "served"
+        && exactKeys(value, ["action", "child", "id", "state"])) {
+        const child = canonicalAkuId(value.child);
+        return child === null ? null : { id: requestId, action, state: value.state, child };
+    }
+    if (action !== "akuma.call"
+        && value.state === "served"
+        && exactKeys(value, ["action", "id", "outcome", "state"])) {
+        const outcome = decodeUpstreamOutcome(value.outcome);
+        return outcome === null ? null : { id: requestId, action, state: value.state, outcome };
     }
-    if (value.state === "refused" && exactKeys(value, ["diagnostic", "id", "state"])
+    if (value.state === "refused"
+        && exactKeys(value, ["action", "diagnostic", "id", "state"])
         && typeof value.diagnostic === "string") {
-        return { id: requestId, state: "refused", diagnostic: value.diagnostic };
+        return { id: requestId, action, state: value.state, diagnostic: value.diagnostic };
     }
-    if (value.state === "voided" && exactKeys(value, ["evidence", "id", "state"])
+    if (value.state === "voided"
+        && exactKeys(value, ["action", "evidence", "id", "state"])
         && typeof value.evidence === "string") {
-        return { id: requestId, state: "voided", evidence: value.evidence };
+        return { id: requestId, action, state: value.state, evidence: value.evidence };
     }
     return null;
 }
@@ -171,16 +265,22 @@ async function atomicJson(path, value) {
     }
 }
 function receiptFor(fact) {
-    if (fact.state === "served")
-        return { id: fact.id, state: fact.state, child: fact.child };
-    if (fact.state === "refused")
-        return { id: fact.id, state: fact.state, diagnostic: fact.diagnostic };
+    if (fact.action === "akuma.call" && fact.state === "served") {
+        return { id: fact.id, action: fact.action, state: fact.state, child: fact.child };
+    }
+    if (fact.state === "refused") {
+        return { id: fact.id, action: fact.action, state: fact.state, diagnostic: fact.diagnostic };
+    }
     if (fact.state === "voided")
-        return { id: fact.id, state: fact.state, evidence: fact.evidence };
+        return { id: fact.id, action: fact.action, state: fact.state, evidence: fact.evidence };
     return null;
 }
-async function projectReceipt(directory, fact) {
-    const receipt = receiptFor(fact);
+async function projectReceipt(directory, fact, outcome) {
+    const receipt = outcome === undefined
+        ? receiptFor(fact)
+        : fact.action === "akuma.call" || fact.state !== "served"
+            ? null
+            : { id: fact.id, action: fact.action, state: fact.state, outcome };
     if (receipt !== null)
         await atomicJson(join(directory, `${fact.id}.receipt.json`), receipt);
 }
@@ -192,45 +292,74 @@ export function injectedBodyRequests() {
         throw new Error(`${AKUMA_REQUESTS_ENV} must be an absolute normalized path`);
     return directory;
 }
-export async function requestBodyCall(input) {
-    await atomicJson(join(input.directory, `${input.id}.request.json`), {
-        id: input.id,
-        world: input.world,
-        archetype: input.archetype,
-        body: input.body,
-        recipe: input.recipe,
-        ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
-    });
-    const receiptPath = join(input.directory, `${input.id}.receipt.json`);
+async function requestBody(input) {
+    const { id, action, ...payload } = input.claim;
+    await atomicJson(join(input.directory, `${id}.request.json`), { id, action, payload });
+    const receiptPath = join(input.directory, `${id}.receipt.json`);
     for (;;) {
         try {
-            const receipt = decodeReceipt(await readFile(receiptPath, "utf8"), input.id);
+            const receipt = decodeReceipt(await readFile(receiptPath, "utf8"), id, action);
             if (receipt === null)
-                throw new Error(`Akuma body request ${input.id} has an invalid receipt`);
-            if (receipt.state === "served")
-                return receipt.child;
+                throw new Error(`Akuma body request ${id} has an invalid receipt`);
             if (receipt.state === "refused")
                 throw new AkumaBodyRequestError("refused", receipt.diagnostic);
-            throw new AkumaBodyRequestError("voided", receipt.evidence);
+            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);
     }
 }
-async function serveClaim(input) {
+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`);
+    }
+    return receipt.child;
+}
+async function requestUpstream(directory, claim) {
+    const receipt = await requestBody({ directory, claim });
+    if (receipt.action === "akuma.call" || receipt.state !== "served") {
+        throw new Error(`Akuma body request ${claim.id} returned the wrong action`);
+    }
+    return receipt.outcome;
+}
+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 serveCallClaim(input) {
     input.signal.throwIfAborted();
-    let fact = await admitRequest(input.paths, { ...input.claim, admittedAt: input.now() });
+    const cwd = input.claim.cwd ?? input.parent.cwd;
+    const recipe = decodeRecipe(input.claim.recipe, cwd);
+    if (recipe === null)
+        return;
+    let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
     const existing = receiptFor(fact);
     if (existing !== null) {
         if (!input.signal.aborted)
             await projectReceipt(input.directory, fact);
         return;
     }
-    if (fact.state !== "admitted")
+    if (fact.action !== "akuma.call" || fact.state !== "admitted") {
         throw new Error(`Akuma request ${fact.id} cannot be replayed from ${fact.state}`);
+    }
     const request = fact;
     const servingWorld = worldRootForAkumaPaths(input.paths);
     if (request.world !== servingWorld) {
@@ -238,7 +367,6 @@ async function serveClaim(input) {
         await projectReceipt(input.directory, fact);
         return;
     }
-    const cwd = resolve(request.cwd ?? servingWorld);
     let child;
     try {
         input.signal.throwIfAborted();
@@ -256,6 +384,7 @@ async function serveClaim(input) {
                     provider: request.recipe.provider,
                     options: request.recipe.options,
                     ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
+                    allowed: request.recipe.allowed,
                     cwd,
                     origin: { kind: "request", parent: input.parent.id, requestId: request.id },
                     confinement: request.recipe.confinement,
@@ -280,6 +409,87 @@ async function serveClaim(input) {
     fact = await serveRequest(input.paths, request.id, child);
     await projectReceipt(input.directory, fact);
 }
+function upstreamFailure(error) {
+    const value = object(error);
+    if (value?.kind === "akuma-not-born") {
+        const id = canonicalAkuId(value.id);
+        if (id !== null)
+            return { kind: "akuma-not-born", id };
+    }
+    return { kind: "failed", diagnostic: diagnostic(error) };
+}
+async function serveUpstreamClaim(input) {
+    input.signal.throwIfAborted();
+    let fact = await admitRequest(input.paths, { ...input.claim, admittedAt: input.now() });
+    const existing = receiptFor(fact);
+    if (existing !== null) {
+        if (!input.signal.aborted)
+            await projectReceipt(input.directory, fact);
+        return;
+    }
+    if (fact.state === "served") {
+        await projectReceipt(input.directory, fact, {
+            kind: "failed",
+            failure: { kind: "failed", diagnostic: "served request receipt is no longer available" },
+        });
+        return;
+    }
+    if (fact.state !== "admitted" || fact.action === "akuma.call") {
+        throw new Error(`Akuma request ${fact.id} cannot be served from ${fact.state}`);
+    }
+    const request = fact;
+    let outcome;
+    let killService = [];
+    try {
+        if (input.upstream === undefined)
+            throw new Error("upstream execution port is unavailable");
+        let result;
+        if (request.action === "akuma.wait") {
+            const waitRequest = request;
+            result = await input.upstream.wait({
+                targets: waitRequest.targets,
+                completion: waitRequest.completion,
+                ...(waitRequest.timeoutMs === undefined ? {} : { timeoutMs: waitRequest.timeoutMs }),
+                signal: input.signal,
+            });
+        }
+        else if (request.action === "akuma.tell") {
+            const tellRequest = request;
+            result = await input.upstream.tell({
+                target: tellRequest.target,
+                body: tellRequest.body,
+                tellId: tellRequest.id,
+                recordedAt: tellRequest.admittedAt,
+                signal: input.signal,
+            });
+        }
+        else {
+            const killRequest = request;
+            const served = await input.upstream.kill({ targets: killRequest.targets, signal: input.signal });
+            killService = served.service;
+            result = served.result;
+        }
+        outcome = { kind: "returned", result };
+    }
+    catch (error) {
+        if (input.signal.aborted)
+            return;
+        outcome = { kind: "failed", failure: upstreamFailure(error) };
+    }
+    input.signal.throwIfAborted();
+    const service = request.action === "akuma.wait"
+        ? { action: request.action }
+        : request.action === "akuma.tell"
+            ? { action: request.action, target: request.target, tellId: request.id }
+            : { action: request.action, results: killService };
+    fact = await serveUpstreamRequest(input.paths, request.id, service);
+    await projectReceipt(input.directory, fact, outcome);
+}
+async function serveClaim(input) {
+    return input.claim.action === "akuma.call"
+        ? await serveCallClaim({ ...input, claim: input.claim })
+        : await serveUpstreamClaim({ ...input, claim: input.claim });
+}
 async function requestFiles(directory) {
     try {
         return (await readdir(directory))
@@ -411,7 +621,8 @@ export async function settleBodyRequests(paths, parent, now, signal) {
         if (request.state === "admitted") {
             await voidRequest(paths, request.id, "body died before serving the request");
         }
-        else if (request.state === "reserved" && !await settleReserved(paths, parent, request, now, signal))
+        else if (request.state === "reserved"
+            && !await settleReserved(paths, parent, request, now, signal))
             pending = true;
     }
     return pending ? "pending" : "settled";

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

@@ -0,0 +1 @@
+export {};

package/build/src/akuma-body.js

@@ -0,0 +1,31 @@
+import { runAkumaBody } from "./akuma/body.js";
+import { worldRootForAkumaPaths } from "./akuma/identity.js";
+import { executeKillAkuma, executeTellAkuma, executeWaitAkuma, } from "./library/fleet.js";
+function upstreamFor(launch) {
+    const path = worldRootForAkumaPaths(launch.paths);
+    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 })),
+            };
+        },
+    };
+}
+await runAkumaBody(upstreamFor);

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

@@ -5,7 +5,10 @@ type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
     projectRefusal?: (refusal: unknown) => unknown;
 }>;
-export declare function acceptedBind(result: BindResult, target: string | null): AcceptedBindResult;
+export declare function acceptedBind(result: BindResult, coordinates: Readonly<{
+    workspace: "worktree" | "here";
+    target?: string;
+}>): AcceptedBindResult;
 export declare function acceptedAmend(result: AmendResult, coordinate: ContractId): AcceptedAmendResult;
 export declare function acceptedDeliver(result: MutationResult<Delivery>, coordinate: ContractId): AcceptedDeliverResult;
 export declare function acceptedReview(result: MutationResult<Review>, coordinate: ContractId): AcceptedReviewResult;

package/build/src/cli/accepted.js

@@ -26,11 +26,12 @@ function acceptedRegion(result) {
         return { overlapFailure: result.overlapFailure };
     return { overlaps: result.overlaps };
 }
-export function acceptedBind(result, target) {
+export function acceptedBind(result, coordinates) {
     return {
         ...acceptedEnvelope(result, undefined),
         verb: "bind",
-        target,
+        workspace: coordinates.workspace,
+        target: coordinates.target ?? null,
         ...acceptedRegion(result),
     };
 }
@@ -44,9 +45,12 @@ export function acceptedAmend(result, coordinate) {
 }
 export function acceptedDeliver(result, coordinate) {
     const value = result.value;
+    const attestation = result.facts.find((fact) => fact.kind === "attestation");
+    const verificationVerdict = attestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "deliver",
+        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
         ...(value.verification === undefined ? {} : { verification: value.verification }),
         ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
@@ -56,18 +60,36 @@ export function acceptedDeliver(result, coordinate) {
 }
 export function acceptedReview(result, coordinate) {
     const value = result.value;
+    const attestation = result.facts.find((fact) => fact.kind === "attestation");
+    if (attestation === undefined)
+        throw new Error("accepted review is missing its attestation fact");
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "review",
+        verdict: attestation.data.verdict,
         ...(value.placement === undefined ? {} : { placement: value.placement }),
         ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
     };
 }
 export function acceptedArc(result, coordinate) {
-    return { ...acceptedEnvelope(result, coordinate), verb: "arc" };
+    const arc = result.facts.find((fact) => fact.kind === "arc");
+    if (arc === undefined)
+        throw new Error("accepted arc is missing its arc fact");
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "arc",
+        chapter: { seq: arc.data.seq, title: arc.data.title },
+    };
 }
 export function acceptedAbandon(result, coordinate) {
-    return { ...acceptedEnvelope(result, coordinate), verb: "abandon" };
+    const abandoned = result.facts.find((fact) => fact.kind === "abandoned");
+    if (abandoned === undefined)
+        throw new Error("accepted abandon is missing its abandoned fact");
+    return {
+        ...acceptedEnvelope(result, coordinate),
+        verb: "abandon",
+        ...(abandoned.data.note === undefined ? {} : { note: abandoned.data.note }),
+    };
 }
 export function acceptedAudit(result, coordinate) {
     return {

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -1,8 +1,8 @@
 import { type AkuId, type ActivityHistory } from "../../akuma/index.js";
-import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaStatusView, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
+import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
-import type { ParsedAkumaCommand } from "./akuma.js";
+import type { InvokedAkumaCommand } from "./akuma.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -11,7 +11,7 @@ export type AkumaInvocationResult = Readonly<{
 }> | Readonly<{
     kind: "akuma";
     action: "status";
-    status: AkumaStatusView;
+    status: AkumaObservation;
     alias?: string;
 }> | Readonly<{
     kind: "akuma";
@@ -67,12 +67,13 @@ export type AkumaInvocationResult = Readonly<{
 }>;
 type InvokeInput = Readonly<{
     path: WorldRoot;
-    executionCwd?: string;
-    settings: Settings;
+    statedCwd?: string;
+    home?: string;
+    settings?: Settings;
     contract?: KeiyakuContract;
     repo?: Repo;
     readStdin(): Promise<string>;
 }>;
-export declare function invokeAkuma(command: ParsedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
-export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, settings: Settings, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
+export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
+export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
 export {};