@astrosheep/keiyaku 4.1.0 → 4.1.2

package/README.md

@@ -94,7 +94,7 @@ did not land until the gates had current evidence.
 kanshi ─ 7 keiyaku · 18 akuma · 286 task ─ /Users/astrosheep/Developer/keiyaku-v4 main 9cfdca6017633e51827b9b2eba3c76a7fe08e05f
 
 keiyaku 7
-⧗ kei/add-acp-provider-and-grok-build-profile pending-delivery
+⧗ kei/add-acp-provider-and-grok-build-profile tendered
   worktree · integration c5cafef6 · -> refs/heads/main
   ! reviewed
 ⧗ kei/align-task-cli-truth-promises waiting

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -39,4 +39,7 @@ keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 `-C` is the invocation and Akuma execution cwd. Add `--repo <path>` only when
 a Contract or Dispatch reader must use a different Git repository.
 
+Repeated `--allowed` values add actions to the Archetype defaults. Restriction
+comes from the Archetype base and, for nested calls, the direct parent Soul.
+
 Use text by default; add `--json` when a script needs structured output.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-akuma/SKILL.md

@@ -29,6 +29,9 @@ exclusive. Decide up front whether you will stay:
 Alias already points elsewhere, it moves to the born Akuma. The worker's
 execution cwd is exactly `-C <path>`, or your own cwd when `-C` is omitted.
 
+Repeated `--allowed` values add actions to the Archetype defaults. Restriction
+comes from the Archetype base and, for nested calls, the direct parent Soul.
+
 ## Archetypes
 
 An Archetype is a Markdown file at `~/.keiyaku/akuma/<name>.md`. Its

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -17,7 +17,7 @@ contract document -> bind -> work -> audit -> deliver -> review gates
                                                                 \-> abandoned
 ```
 
-The lifecycle is `waiting -> bound -> pending-delivery -> claimed | abandoned`;
+The lifecycle is `waiting -> bound -> tendered -> claimed | abandoned`;
 the last two are terminal. Reserve `--after` for true logical ordering: one
 Contract's result must ultimately build on another's settled outcome, or their
 intended work has a large or irreconcilable interaction that should be
@@ -219,7 +219,7 @@ included. Read the receipt:
   delivery is done.
 - When a gate is not current, the receipt shows the recorded candidate and the
   placement stop. This is not a failed delivery. The Contract stays
-  `pending-delivery` while you complete the gates.
+  `tendered` while you complete the gates.
 - A lag row reports an accepted physical effect that has not finished. The
   delivery stands; `reconcile` completes the effect later. It never changes
   the verdict.
@@ -283,10 +283,7 @@ Placement follows the Git mental model you already have:
   The deliver or review you just ran still counts: the recorded candidate and
   any `✓ reviewed` verdict are kept, but nothing claims and nothing moves.
   The target ref, its checkout, and your bytes stay exactly where they were,
-  and the Contract stays `pending-delivery`.
-- A `--here` Contract behaves like a commit with gates: it lands on the current
-  branch and cannot deliver to a foreign checked-out target.
-
+  and the Contract stays `tendered`.
 After a refusal, handle the listed paths, then `deliver` again or record a
 satisfied review; either command requests placement again.
 

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

@@ -0,0 +1,6 @@
+import type { AkuId } from "./identity.js";
+export declare class AkumaNotBornError extends Error {
+    readonly id: AkuId;
+    readonly kind = "akuma-not-born";
+    constructor(id: AkuId);
+}

package/build/src/akuma/akuma-errors.js

@@ -0,0 +1,9 @@
+export class AkumaNotBornError extends Error {
+    id;
+    kind = "akuma-not-born";
+    constructor(id) {
+        super(`Akuma ${id} is not born`);
+        this.id = id;
+        this.name = "AkumaNotBornError";
+    }
+}

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

@@ -0,0 +1,39 @@
+import { type TellResult } from "./body.js";
+import { type KillEvidence } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
+import { type ActivityHistory } from "./projection.js";
+import type { AkumaCallExecution, AkumaStatus, ForkReceipt, InterruptReceipt } from "./akuma.js";
+import type { WorldRoot } from "../world.js";
+declare const CALL_EXECUTION: unique symbol;
+export declare class AkumaHandle {
+    readonly id: AkuId;
+    private readonly worldPath;
+    readonly [CALL_EXECUTION]?: AkumaCallExecution;
+    constructor(id: AkuId, worldPath: WorldRoot, execution?: AkumaCallExecution);
+    private get paths();
+    status(): Promise<AkumaStatus>;
+    history(input?: Readonly<{
+        before?: number;
+        since?: number;
+        limit?: number;
+    }>): Promise<ActivityHistory>;
+    wait(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
+        timeoutMs?: number;
+    }>): Promise<AkumaStatus>;
+    tell(body: string): Promise<TellResult>;
+    interrupt(body: string): Promise<InterruptReceipt>;
+    fork(input: Readonly<{
+        at: string;
+    }>): Promise<ForkReceipt>;
+    kill(): Promise<KillEvidence>;
+    lastAnswer(): Promise<LastAnswer>;
+}
+/** Package-internal provenance retained only by the handle returned from call. */
+export declare function akumaCallExecution(handle: AkumaHandle): AkumaCallExecution | undefined;
+export type LastAnswer = Readonly<{
+    kind: "answer";
+    answer: string;
+}> | Readonly<{
+    kind: "no-answer";
+}>;
+export {};

package/build/src/akuma/akuma-handle.js

@@ -0,0 +1,263 @@
+import { randomUUID } from "node:crypto";
+import { CONTROL_RESPONSE_MS, wakeRecordedTell } from "./body.js";
+import { HeldAkumaLeash, activitySlice, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, recordTell, requestPause, requestStop, } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+import { projectTurns, selectHistory } from "./projection.js";
+import { resolveProviderExecution } from "./providers/index.js";
+import { publishAkuma } from "./publication.js";
+import { spawnAkumaBody } from "./body.js";
+import { AkumaNotBornError } from "./akuma-errors.js";
+import { bornStatus } from "./akuma-observe.js";
+const CALL_EXECUTION = Symbol("akuma-call-execution");
+const POLL_MS = 100;
+const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function defaultWaitComplete(status) {
+    return (status.life !== "running" &&
+        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
+    }
+}
+async function recordTellBody(paths, akuma, body, id = randomUUID(), recordedAt = new Date().toISOString()) {
+    const admitted = await recordTell(paths, { kind: "tell", id, body, recordedAt });
+    if (admitted.kind === "not-born")
+        throw new AkumaNotBornError(akuma);
+    return { kind: "recorded", tellId: admitted.tell.id };
+}
+async function killAkumaWithRecovery(paths, recover = async () => { }) {
+    try {
+        const request = await requestStop(paths, new Date().toISOString());
+        if (request.kind !== "requested")
+            return request.kind;
+        const target = request.body;
+        const leash = await takeLeashUntil(paths, performance.now() + CONTROL_RESPONSE_MS);
+        if ((await readKill(paths, target.sequence)) !== null) {
+            leash?.release();
+            return "killed";
+        }
+        if (leash === null) {
+            if ((await readKill(paths, target.sequence)) !== null)
+                return "killed";
+            const body = (await readHeart(paths)).latestBody;
+            return body?.sequence === target.sequence && body.hung !== undefined ? "hung" : "unavailable";
+        }
+        try {
+            const settledBody = (await readHeart(paths)).latestBody;
+            if (settledBody?.sequence !== target.sequence)
+                return (await readKill(paths, target.sequence)) === null ? "unavailable" : "killed";
+            if (settledBody.end !== "put-down") {
+                await leash.clearStop(paths);
+                return "untidy";
+            }
+            const settled = await leash.settleStop(paths, target.sequence);
+            return settled === null ? "unavailable" : "killed";
+        }
+        finally {
+            leash.release();
+        }
+    }
+    finally {
+        void recover(paths).catch(() => undefined);
+    }
+}
+export class AkumaHandle {
+    id;
+    worldPath;
+    [CALL_EXECUTION];
+    constructor(id, worldPath, execution) {
+        this.id = id;
+        this.worldPath = worldPath;
+        if (execution !== undefined)
+            this[CALL_EXECUTION] = execution;
+    }
+    get paths() {
+        return pathsForAkuId(this.worldPath, this.id);
+    }
+    async status() {
+        return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
+    }
+    async history(input = {}) {
+        if (input.before !== undefined && input.since !== undefined) {
+            throw new TypeError("Akuma history before and since are mutually exclusive");
+        }
+        for (const [name, value] of [
+            ["before", input.before],
+            ["since", input.since],
+        ]) {
+            if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+                throw new TypeError(`Akuma history ${name} must be a positive safe integer`);
+            }
+        }
+        const limit = input.limit ?? 50;
+        if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 5_000) {
+            throw new TypeError("Akuma history limit must be a positive safe integer no greater than 5000");
+        }
+        const slice = await activitySlice(this.paths);
+        return selectHistory(projectTurns(slice.rows, {
+            lowestRetained: slice.lowestRetained,
+            highest: slice.highest,
+        }), {
+            ...(input.before === undefined ? {} : { before: input.before }),
+            ...(input.since === undefined ? {} : { since: input.since }),
+            limit,
+        });
+    }
+    async wait(predicate = defaultWaitComplete, options = {}) {
+        if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
+            throw new TypeError("Akuma wait timeoutMs must be a nonnegative finite millisecond duration");
+        }
+        const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+        for (;;) {
+            const status = await this.status();
+            if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
+                return status;
+            await wait(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
+        }
+    }
+    async tell(body) {
+        const recorded = await recordTellBody(this.paths, this.id, body);
+        return await wakeRecordedTell(this.paths, recorded.tellId);
+    }
+    async interrupt(body) {
+        const request = await requestPause(this.paths, new Date().toISOString());
+        if (request.kind === "not-born") {
+            throw new AkumaNotBornError(this.id);
+        }
+        let putDown = "was-idle";
+        let leash = await HeldAkumaLeash.try(this.paths);
+        if (leash === null) {
+            leash = await takeLeashUntil(this.paths, performance.now() + CONTROL_RESPONSE_MS);
+            putDown = "self-aborted";
+        }
+        if (leash === null) {
+            const body = (await readHeart(this.paths)).latestBody;
+            return {
+                kind: "unavailable",
+                evidence: body?.sequence === request.body.sequence && body.hung !== undefined ? "hung" : "unavailable",
+            };
+        }
+        const settledBody = (await readHeart(this.paths)).latestBody;
+        if (settledBody?.sequence === request.body.sequence && settledBody.hung !== undefined) {
+            try {
+                await leash.clearPause(this.paths);
+            }
+            finally {
+                leash.release();
+            }
+            return { kind: "unavailable", evidence: "hung" };
+        }
+        if (settledBody?.sequence !== request.body.sequence || settledBody.end === undefined) {
+            try {
+                await leash.clearPause(this.paths);
+            }
+            finally {
+                leash.release();
+            }
+            return { kind: "unavailable", evidence: "untidy" };
+        }
+        if (request.body.end !== undefined || settledBody.end !== "put-down")
+            putDown = "was-idle";
+        let recorded;
+        try {
+            const id = randomUUID();
+            const admitted = await leash.recordInterruptTell(this.paths, {
+                kind: "tell",
+                id,
+                body,
+                recordedAt: new Date().toISOString(),
+            });
+            if (admitted.kind === "not-born")
+                throw new AkumaNotBornError(this.id);
+            recorded = { kind: "recorded", tellId: admitted.tell.id };
+        }
+        finally {
+            leash.release();
+        }
+        return { kind: "interrupted", putDown, tell: await wakeRecordedTell(this.paths, recorded.tellId) };
+    }
+    async fork(input) {
+        const source = await readSoul(this.paths);
+        if (source === null)
+            throw new AkumaNotBornError(this.id);
+        if (source.id !== this.id)
+            throw new Error("Akuma soul does not match its coordinate");
+        const adapter = (await resolveProviderExecution(source.provider)).adapter;
+        if (adapter.fork === undefined)
+            return { kind: "provider-cannot-fork", provider: source.provider.name };
+        const point = await readForkPoint(this.paths, input.at);
+        if (point === null)
+            return { kind: "unknown-history", at: input.at };
+        if (point.provider !== source.provider.name)
+            throw new Error(`Akuma fork point ${input.at} has a mismatched provider`);
+        let childSession;
+        try {
+            childSession = (await adapter.fork({ session: point.session, at: point.historyId, cwd: point.cwd })).session;
+        }
+        catch (error) {
+            return { kind: "fork-failed", diagnostic: diagnostic(error) };
+        }
+        const admittedAt = new Date().toISOString();
+        const birthSession = {
+            provider: point.provider,
+            coordinate: childSession,
+            cwd: point.cwd,
+            options: point.options,
+            admittedAt,
+        };
+        try {
+            const child = await publishAkuma({
+                worldPath: this.worldPath,
+                archetype: source.archetype,
+                awaitAsleep: true,
+                launch: async (allocated) => {
+                    (await spawnAkumaBody({
+                        paths: allocated.paths,
+                        seed: {
+                            id: allocated.id,
+                            archetype: source.archetype,
+                            ...(source.description === undefined ? {} : { description: source.description }),
+                            provider: source.provider,
+                            options: source.options,
+                            ...(source.readonly === undefined ? {} : { readonly: source.readonly }),
+                            allowed: source.allowed,
+                            cwd: source.cwd,
+                            origin: { kind: "fork", parent: this.id, at: input.at },
+                        },
+                        birthSession,
+                    })).release();
+                },
+            });
+            return { kind: "forked", child: child.id };
+        }
+        catch (error) {
+            return {
+                kind: "upstream-forked",
+                childSession,
+                diagnostic: diagnostic(error),
+            };
+        }
+    }
+    async kill() {
+        return await killAkumaWithRecovery(this.paths);
+    }
+    async lastAnswer() {
+        const turn = await readLastAnsweredTurn(this.paths);
+        return turn?.end?.outcome.kind === "answered"
+            ? { kind: "answer", answer: turn.end.outcome.answer }
+            : { kind: "no-answer" };
+    }
+}
+/** Package-internal provenance retained only by the handle returned from call. */
+export function akumaCallExecution(handle) {
+    return handle[CALL_EXECUTION];
+}

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

@@ -0,0 +1,19 @@
+import { type AkuId, type AkumaPaths } from "./identity.js";
+import { selectHistory, type ActivityHistory, type ActivitySnapshot } from "./projection.js";
+import type { WorldRoot } from "../world.js";
+import type { AkumaListRow, AkumaStatus, UnbornAkumaListRow } from "./akuma.js";
+export declare function fleetListRow(paths: AkumaPaths, expected: AkuId): Promise<AkumaListRow | UnbornAkumaListRow>;
+export type BudgetedStatusObservation = Readonly<{
+    status: AkumaStatus;
+    ordinarySelected: number;
+}>;
+export declare function bornStatus(paths: AkumaPaths, expected: AkuId, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    ordinaryBudget?: number;
+}>): Promise<BudgetedStatusObservation>;
+export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    ordinaryBudget?: number;
+}>): Promise<BudgetedStatusObservation>;
+export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
+export { selectHistory, type ActivityHistory, type ActivitySnapshot };

package/build/src/akuma/akuma-observe.js

@@ -0,0 +1,74 @@
+import { activitySlice, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, } from "./projection.js";
+import { resolveProviderExecution } from "./providers/index.js";
+import { AkumaNotBornError } from "./akuma-errors.js";
+export async function fleetListRow(paths, expected) {
+    const snapshot = await readHeart(paths);
+    if (snapshot.soul !== null)
+        return await bornListRow(paths, expected, snapshot);
+    try {
+        if ((await probeLeash(paths)) === "held")
+            return { id: expected, life: "unborn" };
+        const seal = await readSeal(paths);
+        return seal === null ? { id: expected, life: "unborn" } : { id: expected, life: "stillborn", seal };
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return { id: expected, life: "unborn" };
+        throw error;
+    }
+}
+async function bornListRow(paths, expected, snapshot) {
+    snapshot ??= await readHeart(paths);
+    if (snapshot.soul === null)
+        throw new AkumaNotBornError(expected);
+    if (snapshot.soul.id !== expected)
+        throw new Error("Akuma soul does not match its coordinate");
+    const currentLife = life({ leash: await probeLeash(paths), body: snapshot.latestBody, kill: snapshot.latestKill });
+    return {
+        id: snapshot.soul.id,
+        archetype: snapshot.soul.archetype,
+        ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
+        life: currentLife,
+        lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, snapshot.soul.createdAt),
+        lastActivityAt: snapshot.lastActivityAt,
+        pending: snapshot.pending.map((tell) => tell.id),
+    };
+}
+export async function bornStatus(paths, expected, input) {
+    if (input.ordinaryBudget !== undefined && (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0))
+        throw new TypeError("ordinary budget must be a nonnegative safe integer");
+    const snapshot = await readHeart(paths);
+    if (snapshot.soul === null)
+        throw new AkumaNotBornError(expected);
+    const current = await bornListRow(paths, expected, snapshot);
+    const resumeUnsupported = current.life === "stranded" &&
+        snapshot.latestSession?.provider === snapshot.soul.provider.name &&
+        (await resolveProviderExecution(snapshot.soul.provider)).adapter.resume === undefined;
+    const slice = await activitySlice(paths);
+    const selected = selectSnapshot(projectTurns(slice.rows), {
+        aperture: input.aperture,
+        budget: ordinarySnapshotBudget(input.ordinaryBudget),
+    });
+    return {
+        status: {
+            id: current.id,
+            life: current.life,
+            ...(snapshot.soul.readonly === undefined ? {} : { readonly: snapshot.soul.readonly }),
+            ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
+            timeline: selected.snapshot,
+        },
+        ordinarySelected: selected.ordinaryCount,
+    };
+}
+export async function readBudgetedStatus(worldPath, id, input) {
+    return await bornStatus(pathsForAkuId(worldPath, id), id, input);
+}
+export async function readAkumaBirthCwd(worldPath, id) {
+    const soul = await readSoul(pathsForAkuId(worldPath, id));
+    if (soul === null)
+        throw new AkumaNotBornError(id);
+    return soul.cwd;
+}
+export { selectHistory };

package/build/src/akuma/akuma-product-symbols.d.ts

@@ -0,0 +1 @@
+export declare const CALL_WITH_CONTEXT: unique symbol;

package/build/src/akuma/akuma-product-symbols.js

@@ -0,0 +1 @@
+export const CALL_WITH_CONTEXT = Symbol("akuma-call-with-context");

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

@@ -0,0 +1,18 @@
+import { AkumaHandle } from "./akuma-handle.js";
+import type { AkumaCallContext, AkumaCallInput, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
+import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+import type { WorldRoot } from "../world.js";
+export declare class Akuma {
+    private readonly path;
+    private readonly configuration;
+    private constructor();
+    static of(root: WorldRoot, input?: AkumaConfiguration): Akuma;
+    of(input: Readonly<{
+        id: string;
+    }>): AkumaHandle;
+    listArchetypes(): Promise<readonly string[]>;
+    call(input: AkumaCallInput): Promise<AkumaHandle>;
+    [CALL_WITH_CONTEXT](input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
+    list(input?: AkumaListInput): Promise<AkumaList>;
+}
+export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;

package/build/src/akuma/akuma-product.js

@@ -0,0 +1,154 @@
+import { randomUUID } from "node:crypto";
+import { readdir, realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AkumaHandle } from "./akuma-handle.js";
+import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+import { fleetListRow, readAkumaBirthCwd } from "./akuma-observe.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, archetypeName, parseAkuId } from "./identity.js";
+import { loadArchetype, listArchetypes as readArchetypes } from "./archetype.js";
+import { publishAkuma } from "./publication.js";
+import { spawnAkumaBody } from "./body.js";
+import { injectedBodyRequests, requestBodyCall } from "./requests.js";
+import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
+import { settings as readSettings } from "../settings.js";
+function callReadonly(value) {
+    if (value === undefined)
+        return {};
+    if (value !== true)
+        throw new TypeError("Akuma call readonly must be true");
+    return { readonly: true };
+}
+async function canonicalBirthCwd(input) {
+    const selected = resolve(input);
+    try {
+        const canonical = await realpath(selected);
+        if (!(await stat(canonical)).isDirectory())
+            throw new Error("not a directory");
+        return canonical;
+    }
+    catch {
+        throw new Error(`cwd is not an existing directory: ${input}`);
+    }
+}
+export class Akuma {
+    path;
+    configuration;
+    constructor(path, configuration) {
+        this.path = path;
+        this.configuration = configuration;
+    }
+    static of(root, input = {}) {
+        if (typeof root !== "string")
+            throw new TypeError("Akuma.of root must be a WorldRoot");
+        return new Akuma(root, input);
+    }
+    of(input) {
+        return new AkumaHandle(parseAkuId(input.id).id, this.path);
+    }
+    async listArchetypes() {
+        return readArchetypes(this.configuration.home === undefined ? {} : { home: this.configuration.home });
+    }
+    async call(input) {
+        return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
+    }
+    async [CALL_WITH_CONTEXT](input, context) {
+        const readonly = callReadonly(input.readonly);
+        const name = archetypeName(input.archetype);
+        const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
+        const settings = this.configuration.settings ?? (await readSettings({ root: this.path, ...home }));
+        const archetype = await loadArchetype({ name, ...home, settings, ...readonly });
+        const allowed = input.allowed === undefined
+            ? archetype.allowed
+            : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
+        const requests = injectedBodyRequests();
+        const requestRecipe = Object.freeze({
+            ...(archetype.description === undefined ? {} : { description: archetype.description }),
+            provider: archetype.provider,
+            options: archetype.options,
+            ...(archetype.readonly === undefined ? {} : { readonly: archetype.readonly }),
+            allowed,
+        });
+        if (requests !== null) {
+            const cwd = input.cwd === undefined
+                ? undefined
+                : context?.cwdCanonical === true
+                    ? input.cwd
+                    : await canonicalBirthCwd(input.cwd);
+            const child = await requestBodyCall({
+                directory: requests,
+                id: randomUUID(),
+                world: this.path,
+                archetype: name,
+                body: input.body,
+                ...(cwd === undefined ? {} : { cwd }),
+                recipe: requestRecipe,
+            });
+            const bornCwd = await readAkumaBirthCwd(this.path, child);
+            return new AkumaHandle(child, this.path, { cwd: bornCwd, source: cwd === undefined ? "caller" : "input" });
+        }
+        const initiatorCwd = context.initiatorCwd;
+        const selectedCwd = input.cwd ?? initiatorCwd ?? this.path;
+        const cwd = input.cwd !== undefined && context?.cwdCanonical === true ? input.cwd : await canonicalBirthCwd(selectedCwd);
+        const published = await publishAkuma({
+            worldPath: this.path,
+            archetype: archetype.name,
+            launch: async (allocated) => (await spawnAkumaBody({
+                paths: allocated.paths,
+                seed: {
+                    id: allocated.id,
+                    archetype: allocated.archetype,
+                    ...requestRecipe,
+                    cwd,
+                    origin: { kind: "direct" },
+                },
+                initialBody: input.body,
+            })).release(),
+        });
+        return new AkumaHandle(published.id, this.path, {
+            cwd,
+            source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
+        });
+    }
+    async list(input = {}) {
+        if (typeof input !== "object" || input === null || Array.isArray(input))
+            throw new TypeError("Akuma list input must be an object");
+        const unknown = Object.keys(input).find((key) => key !== "archetype");
+        if (unknown !== undefined)
+            throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
+        const selected = input.archetype === undefined ? undefined : archetypeName(input.archetype);
+        const runRoot = akumaRunRoot(this.path);
+        let names;
+        try {
+            names = (await readdir(runRoot, { withFileTypes: true }))
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name)
+                .sort();
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { rows: [], searched: [runRoot] };
+            throw error;
+        }
+        const rows = [];
+        for (const name of names) {
+            let physical;
+            try {
+                physical = akuIdFromDirectoryName(name);
+            }
+            catch {
+                continue;
+            }
+            if (selected !== undefined && physical.archetype !== selected)
+                continue;
+            const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+            try {
+                rows.push(await fleetListRow(paths, physical.id));
+            }
+            catch { }
+        }
+        return { rows, searched: [runRoot] };
+    }
+}
+export async function callAkumaWithContext(akuma, input, context) {
+    return await akuma[CALL_WITH_CONTEXT](input, context);
+}