@astrosheep/keiyaku 4.5.0 → 4.5.2

package/build/src/akuma/request-serve.js

@@ -1,19 +1,26 @@
-import { access, mkdir, readFile, readdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { abortableDelay } from "./abort.js";
-import { HeldAkumaLeash, admitRequest, readNonterminalRequests, readRequest, readSoul, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
-import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
-import { BIRTH_TIMEOUT_MS, publishAkuma } from "./publication.js";
-import { atomicJson, canonicalAkuId, decodeClaim, decodeRecipe, receiptPath, } from "./request-wire.js";
+import { admitRequest, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { worldRootForAkumaPaths } from "./identity.js";
+import { publishAkuma } from "./publication.js";
+import { atomicJson, canonicalAkuId, decodeRecipe, receiptPath, } from "./request-wire.js";
 import { isTaskMutationAction } from "../task/mutation.js";
 import { executeRequest } from "./request-execution.js";
-const POLL_MS = 100;
+import { BodyRequestPump as LifecycleBodyRequestPump, } from "./request-lifecycle.js";
+export { clearBodyRequestTransport, settleBodyRequests } from "./request-lifecycle.js";
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function isTask(value) {
     return isTaskMutationAction(value.action);
 }
+function refusalRecipe(value) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+        const recipe = value;
+        if (Array.isArray(recipe.allowed))
+            return recipe;
+        return { ...recipe, allowed: [] };
+    }
+    return { allowed: [] };
+}
 function acceptedReceipt(fact, service) {
     return {
         id: fact.id,
@@ -62,7 +69,7 @@ function receiptFor(fact) {
     }
     return null;
 }
-async function projectReceipt(directory, fact, outcome) {
+async function projectReceipt(directory, transportId, fact, outcome) {
     const receipt = outcome === undefined
         ? receiptFor(fact)
         : fact.action === "akuma.call"
@@ -71,29 +78,45 @@ async function projectReceipt(directory, fact, outcome) {
     if (receipt === null)
         return;
     try {
-        await atomicJson(receiptPath(directory, fact.id), receipt);
+        await atomicJson(receiptPath(directory, transportId), receipt);
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
+async function refuseInvalidCall(input) {
+    let fact = await admitRequest(input.paths, {
+        ...input.claim,
+        recipe: refusalRecipe(input.claim.recipe),
+        admittedAt: input.now(),
+    });
+    const existing = receiptFor(fact);
+    if (existing !== null) {
+        await projectReceipt(input.directory, input.transportId, fact);
+        return;
+    }
+    fact = await refuseRequest(input.paths, input.claim.id, "invalid akuma.call recipe");
+    await projectReceipt(input.directory, input.transportId, fact);
+}
 async function serveCall(input) {
     input.signal.throwIfAborted();
     if (!input.admissionOpen())
         return;
     const recipe = decodeRecipe(input.claim.recipe);
-    if (recipe === null)
+    if (recipe === null) {
+        await refuseInvalidCall(input);
         return;
+    }
     let fact = await admitRequest(input.paths, { ...input.claim, recipe, admittedAt: input.now() });
     const existing = receiptFor(fact);
     if (existing !== null) {
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (!input.admissionOpen()) {
         fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.action !== "akuma.call" || fact.state !== "admitted") {
@@ -103,7 +126,7 @@ async function serveCall(input) {
     const world = worldRootForAkumaPaths(input.paths);
     if (request.world !== world) {
         fact = await refuseRequest(input.paths, request.id, `request world ${request.world} does not match ${world}`);
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     try {
@@ -136,7 +159,7 @@ async function serveCall(input) {
                 });
             },
         });
-        fact = await serveRequest(input.paths, request.id, published.id);
+        fact = await serveChildRequest(input.paths, request.id, published.id);
     }
     catch (error) {
         const current = await readRequest(input.paths, request.id);
@@ -147,7 +170,7 @@ async function serveCall(input) {
                 ? await voidRequest(input.paths, request.id, diagnostic(error))
                 : current;
     }
-    await projectReceipt(input.directory, fact);
+    await projectReceipt(input.directory, input.transportId, fact);
 }
 function failure(error) {
     const value = error !== null && typeof error === "object" ? error : null;
@@ -174,11 +197,11 @@ async function serveUpstream(input) {
     });
     const existing = receiptFor(fact);
     if (existing !== null) {
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.state === "served") {
-        await projectReceipt(input.directory, fact, {
+        await projectReceipt(input.directory, input.transportId, fact, {
             kind: "failed",
             failure: {
                 kind: "failed",
@@ -189,7 +212,7 @@ async function serveUpstream(input) {
     }
     if (!input.admissionOpen()) {
         fact = await voidRequest(input.paths, input.claim.id, "body closed request admission");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     if (fact.state !== "admitted" || fact.action === "akuma.call") {
@@ -207,171 +230,22 @@ async function serveUpstream(input) {
     catch (error) {
         outcome = { kind: "failed", failure: failure(error) };
         fact = await voidRequest(input.paths, request.id, "body failed before serving the request");
-        await projectReceipt(input.directory, fact);
+        await projectReceipt(input.directory, input.transportId, fact);
         return;
     }
     fact =
         service === undefined
             ? await voidRequest(input.paths, request.id, "body completed without a durable Contract fact reference")
             : await serveUpstreamRequest(input.paths, request.id, service);
-    await projectReceipt(input.directory, fact, outcome);
+    await projectReceipt(input.directory, input.transportId, fact, outcome);
 }
-async function serve(input) {
+export async function serveRequest(input) {
     return input.claim.action === "akuma.call"
         ? await serveCall({ ...input, claim: input.claim })
         : await serveUpstream({ ...input, claim: input.claim });
 }
-async function requestFiles(directory) {
-    try {
-        return (await readdir(directory)).filter((name) => name.endsWith(".request.json")).sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-export class BodyRequestPump {
-    input;
-    directory;
-    failure;
-    closeSignal = new AbortController();
-    executionSignal = new AbortController();
-    handled = new Set();
-    running;
-    cancelBody;
-    admissionClosed = false;
-    constructor(input) {
-        this.input = input;
-        this.directory = join(input.paths.directory, "requests", String(input.bodySequence));
-        this.cancelBody = () => {
-            this.stopAdmission();
-            if (!this.executionSignal.signal.aborted) {
-                this.executionSignal.abort(input.signal.reason);
-            }
-        };
-        input.signal.addEventListener("abort", this.cancelBody, { once: true });
-        if (input.signal.aborted)
-            this.cancelBody();
-        this.running = this.run();
-        this.failure = this.running.then(() => new Promise(() => { }), (error) => Promise.reject(error));
-    }
+export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        await mkdir(join(input.paths.directory, "requests", String(input.bodySequence)), { recursive: true });
-        return new BodyRequestPump(input);
-    }
-    async run() {
-        while (!this.closeSignal.signal.aborted) {
-            for (const name of await requestFiles(this.directory)) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                const id = name.slice(0, -".request.json".length);
-                if (this.handled.has(id))
-                    continue;
-                const path = join(this.directory, name);
-                const claim = decodeClaim(await readFile(path, "utf8"), id);
-                if (claim === null) {
-                    await rm(path, { force: true });
-                    this.handled.add(id);
-                    continue;
-                }
-                if (!this.admissionClosed) {
-                    await serve({
-                        directory: this.directory,
-                        claim,
-                        ...this.input,
-                        signal: this.executionSignal.signal,
-                        admissionOpen: () => !this.admissionClosed,
-                    });
-                }
-                this.handled.add(id);
-            }
-            try {
-                await abortableDelay(POLL_MS, this.closeSignal.signal);
-            }
-            catch (error) {
-                if (this.closeSignal.signal.aborted)
-                    return;
-                throw error;
-            }
-        }
-    }
-    async close() {
-        this.stopAdmission();
-        try {
-            await this.running;
-        }
-        finally {
-            this.input.signal.removeEventListener("abort", this.cancelBody);
-            await rm(this.directory, { recursive: true, force: true });
-        }
-    }
-    stopAdmission() {
-        this.admissionClosed = true;
-        if (!this.closeSignal.signal.aborted) {
-            this.closeSignal.abort(new Error("Body request pump closed"));
-        }
-    }
-}
-export async function clearBodyRequestTransport(paths) {
-    await rm(join(paths.directory, "requests"), { recursive: true, force: true });
-}
-function matchingRequestOrigin(soul, parent, id) {
-    return soul.origin.kind === "request" && soul.origin.parent === parent && soul.origin.requestId === id;
-}
-async function settleReservedSoul(paths, parent, request, soul) {
-    await (matchingRequestOrigin(soul, parent.id, request.id)
-        ? serveRequest(paths, request.id, request.child)
-        : voidRequest(paths, request.id, "reserved child origin does not match the request"));
-}
-async function settleReserved(paths, parent, request, now, signal) {
-    const childPaths = pathsForAkuId(request.world, request.child);
-    const deadline = performance.now() + BIRTH_TIMEOUT_MS;
-    for (;;) {
-        signal?.throwIfAborted();
-        if (!(await access(childPaths.directory).then(() => true, () => false))) {
-            await voidRequest(paths, request.id, "reserved child directory is absent");
-            return true;
-        }
-        const soul = await readSoul(childPaths);
-        if (soul !== null) {
-            await settleReservedSoul(paths, parent, request, soul);
-            return true;
-        }
-        const leash = await HeldAkumaLeash.try(childPaths);
-        if (leash !== null) {
-            try {
-                const settled = await readSoul(childPaths);
-                if (settled !== null) {
-                    await settleReservedSoul(paths, parent, request, settled);
-                }
-                else {
-                    await leash.sealIfUnborn(childPaths, {
-                        evidence: "request settlement",
-                        at: now(),
-                    });
-                    await voidRequest(paths, request.id, "reserved child was sealed unborn");
-                }
-            }
-            finally {
-                leash.release();
-            }
-            return true;
-        }
-        if (performance.now() >= deadline)
-            return false;
-        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
-    }
-}
-export async function settleBodyRequests(paths, parent, now, signal) {
-    let pending = false;
-    for (const request of await readNonterminalRequests(paths)) {
-        signal?.throwIfAborted();
-        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)))
-            pending = true;
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveRequest(claim)));
     }
-    return pending ? "pending" : "settled";
 }

package/build/src/akuma/request-wire.js

@@ -210,7 +210,7 @@ export function decodeClaim(bytes, fileId) {
     const value = object(decoded);
     if (value === null ||
         !exactKeys(value, ["action", "id", "payload"]) ||
-        value.id !== fileId ||
+        !UUID.test(fileId) ||
         typeof value.id !== "string" ||
         !UUID.test(value.id))
         return null;

package/build/src/akuma/requests.js

@@ -26,12 +26,13 @@ export function injectedBodyRequests() {
 }
 async function requestBody(input) {
     input.signal?.throwIfAborted();
-    await atomicJson(requestPath(input.directory, input.claim.id), {
+    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, input.claim.id);
+    const path = receiptPath(input.directory, transportId);
     for (;;) {
         try {
             const receipt = decodeReceipt(await readFile(path, "utf8"), input.claim.id, input.claim.action);

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

@@ -3,6 +3,7 @@ import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObser
 import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
 import type { InvokedAkumaCommand } from "./akuma.js";
+import { finishCall } from "../../library/akuma-creation.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -55,6 +56,13 @@ export type AkumaInvocationResult = Readonly<{
     mode: "no-answer";
     historyResult: AkumaHistoryResult;
     alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "history";
+    akuma: AkuId;
+    mode: "exact";
+    historyResult: AkumaHistoryResult;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "fork";
@@ -74,6 +82,7 @@ type InvokeInput = Readonly<{
     repo?: Repo;
     environment: NodeJS.ProcessEnv;
     readStdin(): Promise<string>;
+    finishCall?: typeof finishCall;
 }>;
 export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
 export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;

package/build/src/cli/commands/akuma-invoke.js

@@ -58,6 +58,7 @@ async function invokeHistory(command, input) {
         ...(command.before === undefined ? {} : { before: command.before }),
         ...(command.since === undefined ? {} : { since: command.since }),
         ...(command.limit === undefined ? {} : { limit: command.limit }),
+        ...(command.id === undefined ? {} : { id: command.id }),
         last: command.last,
     });
     return {
@@ -66,11 +67,13 @@ async function invokeHistory(command, input) {
         akuma: result.id,
         historyResult: result,
         ...(inputAlias(command.akuma) === undefined ? {} : { alias: command.akuma }),
-        ...(result.kind === "history"
-            ? { mode: "page", history: result.history }
-            : result.kind === "last"
-                ? { mode: "last", answer: result.answer }
-                : { mode: "no-answer" }),
+        ...(command.id !== undefined
+            ? { mode: "exact" }
+            : result.kind === "history"
+                ? { mode: "page", history: result.history }
+                : result.kind === "last"
+                    ? { mode: "last", answer: result.answer }
+                    : { mode: "no-answer" }),
     };
 }
 async function invokeFork(command, input) {
@@ -121,7 +124,7 @@ export async function invokeAkuma(command, input) {
                 : undefined;
             let result;
             try {
-                result = await finishCall(born);
+                result = await (input.finishCall ?? finishCall)(born, listener?.participantName);
             }
             catch (error) {
                 if (listener?.committed === true) {

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

@@ -38,6 +38,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
 }> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;
+    id?: string;
     before?: number;
     since?: number;
     limit?: number;

package/build/src/cli/commands/akuma.js

@@ -3,6 +3,7 @@ import { parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
 import { decodeAllowedActions } from "../../akuma/allowed.js";
+import { parsePublicHistoryId } from "../../akuma/identity.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
         arity: 1,
@@ -49,8 +50,8 @@ const AKUMA_COMMAND_SPECS = {
     history: {
         arity: 1,
         stdin: false,
-        flags: { before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
-        usage: "history <aku/...|@alias|kei/...> [--before <index> | --since <index>] [--limit <count>] [--last]",
+        flags: { id: "value", before: "value", since: "value", limit: "value", last: "boolean", json: "boolean" },
+        usage: "history <aku/...|@alias|kei/...> [--id <historyId> | --before <index> | --since <index>] [--limit <count>] [--last]",
         purpose: "Read Akuma execution history or one complete Contract journal and Dispatch timeline.",
     },
     fork: {
@@ -203,22 +204,31 @@ function parseWait(rawSelectors, flags, output, fail) {
 }
 function parseHistory(selector, flags, output, fail) {
     if (selector.startsWith("kei/")) {
-        if (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined || flags.last === true) {
-            fail("history kei/... does not accept --before, --since, --limit, or --last");
+        if ([flags.id, flags.before, flags.since, flags.limit, flags.last].some((value) => value !== undefined)) {
+            fail("history kei/... does not accept --id, --before, --since, --limit, or --last");
         }
         return { command: "history", contract: selector, output };
     }
+    return parseAkumaHistory(selector, flags, output, fail);
+}
+function parseAkumaHistory(selector, flags, output, fail) {
+    const bounded = flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined;
     if (flags.before !== undefined && flags.since !== undefined)
         fail("history --before and --since are mutually exclusive");
-    if (flags.last === true && (flags.before !== undefined || flags.since !== undefined || flags.limit !== undefined)) {
+    if (flags.id !== undefined && (flags.last === true || bounded))
+        fail("history --id cannot be combined with --last, --before, --since, or --limit");
+    if (flags.last === true && bounded)
         fail("history --last cannot be combined with --before, --since, or --limit");
-    }
     const limit = flags.limit === undefined ? undefined : positiveIndex(flags.limit, "--limit", fail);
     if (limit !== undefined && limit > 5_000)
         fail("--limit must be no greater than 5000");
+    const id = flags.id === undefined ? undefined : stringFlag(flags.id, "history --id requires a nonblank historyId", fail);
+    if (id !== undefined && parsePublicHistoryId(id) === null)
+        fail("history --id requires turn/<positive safe integer>");
     return {
         command: "history",
         akuma: validateDirect(selector, fail),
+        ...(id === undefined ? {} : { id }),
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
         ...(flags.since === undefined ? {} : { since: positiveIndex(flags.since, "--since", fail) }),

package/build/src/cli/commands/contract.d.ts

@@ -56,6 +56,7 @@ export type ParsedAbandon = Output & Actor & Readonly<{
 export type ParsedStatus = Output & (Readonly<{
     command: "status";
     contract?: string;
+    selectors?: readonly string[];
     akuma?: never;
 }> | Readonly<{
     command: "status";
@@ -178,8 +179,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly flags: {
             readonly json: "boolean";
         };
-        readonly usage: "status [<contract>|@name|<aku/...>]";
-        readonly purpose: "Read the world status board or one Contract projection.";
+        readonly usage: "status [<contract>|@name|<aku/...>]...";
+        readonly purpose: "Read the world status board or one or more Contract and Akuma projections.";
     };
     readonly show: {
         readonly positional: "optional";

package/build/src/cli/commands/contract.js

@@ -87,8 +87,8 @@ export const CONTRACT_COMMAND_SPECS = {
         positional: "optional",
         stdin: "none",
         flags: { json: "boolean" },
-        usage: "status [<contract>|@name|<aku/...>]",
-        purpose: "Read the world status board or one Contract projection.",
+        usage: "status [<contract>|@name|<aku/...>]...",
+        purpose: "Read the world status board or one or more Contract and Akuma projections.",
     },
     show: {
         positional: "optional",
@@ -244,6 +244,9 @@ function parseReview(parts) {
     };
 }
 function parseStatus(parts) {
+    if (parts.positionals.length > 1) {
+        return { command: "status", selectors: parts.positionals, output: parts.output };
+    }
     const contract = parts.positionals[0];
     if (contract?.startsWith("aku/") === true) {
         return { command: "status", contract, akuma: true, output: parts.output };

package/build/src/cli/commands/status-set.d.ts

@@ -0,0 +1,4 @@
+import type { StatusSetResult } from "../result.js";
+import type { Repo } from "../../library/repo.js";
+import type { WorldRoot } from "../../world.js";
+export declare function invokeStatusSet(selectors: readonly string[], world: WorldRoot | null, repo: Repo | undefined): Promise<StatusSetResult>;

package/build/src/cli/commands/status-set.js

@@ -0,0 +1,61 @@
+import { CliUsageError } from "../parse.js";
+import { canonicalContractSelector } from "../selectors.js";
+async function statusSetAkuma(selector, id, alias, world, repo) {
+    if (world === null)
+        throw new CliUsageError("no Keiyaku world contains the Akuma selector");
+    const result = await (await import("./akuma-invoke.js")).invokeAkumaStatus(world, id, alias, repo);
+    if (result.action !== "status")
+        throw new Error("status invocation returned a non-status Akuma result");
+    return {
+        selector,
+        kind: "akuma",
+        status: result.status,
+        ...(result.alias === undefined ? {} : { alias: result.alias }),
+    };
+}
+async function statusSetEntry(selector, world, repo, observed) {
+    let resolved = selector;
+    let alias;
+    if (selector.startsWith("@")) {
+        if (observed === undefined)
+            throw new CliUsageError("cannot resolve a named status selector");
+        const { resolveNamedAddress } = await import("../../library/address.js");
+        const address = resolveNamedAddress({ selector, report: observed.report, aliases: observed.aliases });
+        if (address.kind === "akuma")
+            return await statusSetAkuma(selector, address.id, selector, world, repo);
+        resolved = address.id;
+        alias = selector;
+    }
+    if (resolved.startsWith("aku/"))
+        return await statusSetAkuma(selector, resolved, alias, world, repo);
+    if (repo === undefined)
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    if (observed === undefined)
+        throw new CliUsageError("cannot observe Contract status without a Kanshi report");
+    return {
+        selector,
+        kind: "contract",
+        report: (await import("../../kanshi/index.js")).selectKanshi({
+            report: observed.report,
+            contract: canonicalContractSelector(resolved),
+        }),
+    };
+}
+export async function invokeStatusSet(selectors, world, repo) {
+    if (selectors.length < 2)
+        throw new CliUsageError("status requires at least two selectors");
+    if (selectors.some((selector) => !selector.startsWith("aku/") && !selector.startsWith("@")) && repo === undefined) {
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    }
+    const needsKanshi = selectors.some((selector) => !selector.startsWith("aku/"));
+    const observed = needsKanshi
+        ? await (await import("../../kanshi/index.js")).observeKanshi({
+            world,
+            ...(repo === undefined ? {} : { repo }),
+        })
+        : undefined;
+    const entries = [];
+    for (const selector of selectors)
+        entries.push(await statusSetEntry(selector, world, repo, observed));
+    return { kind: "status-set", entries };
+}

package/build/src/cli/invoke.js

@@ -158,6 +158,11 @@ async function invokeCatalog(parsed, world, repo, home) {
     }
 }
 async function invokeStatus(parsed, world, repo) {
+    const selectors = "selectors" in parsed ? parsed.selectors : undefined;
+    if (selectors !== undefined) {
+        const { invokeStatusSet } = await import("./commands/status-set.js");
+        return await invokeStatusSet(selectors, world, repo);
+    }
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");

package/build/src/cli/parse.js

@@ -164,7 +164,7 @@ function scanArgv(argv) {
     if (spec.positional === "none" && state.positionals.length > 0) {
         refuse(command, `${command} accepts no contract`);
     }
-    if (spec.positional === "optional" && state.positionals.length > 1) {
+    if (spec.positional === "optional" && state.positionals.length > 1 && command !== "status") {
         refuse(command, `${command} accepts at most one contract`);
     }
     if (spec.stdin === "required" && !state.stdin) {

package/build/src/cli/render/akuma-activity.js

@@ -316,6 +316,11 @@ export function akumaRawAnswer(result) {
     }
     if (result.action === "wait" && result.result.observations.length === 1)
         return statusAnswer(result.result.observations[0]);
+    if (result.action === "history" && result.mode === "exact" && result.historyResult.kind === "exact") {
+        return result.historyResult.outcome.outcome.kind === "answered"
+            ? result.historyResult.outcome.outcome.answer
+            : result.historyResult.outcome.outcome.diagnostic;
+    }
     return undefined;
 }
 export function waitText(result, context) {
@@ -336,6 +341,12 @@ export function waitText(result, context) {
     return [...blocks, `${done} of ${total} done`].join("\n\n");
 }
 export function historyText(command, result, context) {
+    if (result.mode === "exact") {
+        const exact = result.historyResult;
+        if (exact.kind !== "exact")
+            return `${exact.kind === "unknown-history" ? exact.historyId : "unknown"} has no matching retained outcome`;
+        return exact.outcome.outcome.kind === "answered" ? exact.outcome.outcome.answer : exact.outcome.outcome.diagnostic;
+    }
     if (command.last)
         return result.mode === "last" ? result.answer : "no answer retained";
     if (result.mode !== "page")

package/build/src/cli/render/akuma.js

@@ -123,6 +123,11 @@ function tellExitCode(result) {
 function forkExitCode(result) {
     return result.receipt.kind === "forked" ? 0 : result.receipt.kind === "upstream-forked" ? 2 : 1;
 }
+function historyExitCode(result) {
+    if (result.mode !== "exact")
+        return 0;
+    return result.historyResult.kind === "exact" ? 0 : 1;
+}
 export function akumaExitCode(result) {
     switch (result.action) {
         case "call":
@@ -133,6 +138,8 @@ export function akumaExitCode(result) {
             return tellExitCode(result);
         case "fork":
             return forkExitCode(result);
+        case "history":
+            return historyExitCode(result);
         default:
             return 0;
     }

package/build/src/cli/render/status-set.d.ts

@@ -0,0 +1,5 @@
+import type { InvocationResult } from "../result.js";
+import type { TextRenderContext } from "./terminal.js";
+export declare function renderStatusSetText(result: Extract<InvocationResult, {
+    kind: "status-set";
+}>, context?: TextRenderContext): string;