@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/akuma/body.js

@@ -3,9 +3,10 @@ import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, projectTell, readHeart, readTell, readNonterminalRequests, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, provePendingTellDispositionCustody, readHeart, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, recordUndeliveredPendingTells, resolvePendingTellDisposition, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
-import { keiyakuSquarePath } from "../world.js";
+import { pluginRuntime } from "../plugin/runtime.js";
+import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
@@ -16,8 +17,14 @@ export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
+async function failOpenBoundTurnsIfPresent(paths, bodySequence, diagnostic, at) {
+    if (!(await heartExists(paths)))
+        return;
+    await failOpenBoundTurns(paths, { bodySequence, diagnostic, completedAt: at });
+}
 async function putDownIfControlled(paths, supervisor, bodySequence, now) {
     if (supervisor.reason === "control" && (await heartExists(paths))) {
+        await failOpenBoundTurnsIfPresent(paths, bodySequence, "Body put-down with open bound Turns", now());
         await breakBody(paths, { sequence: bodySequence, end: "put-down", at: now() });
     }
 }
@@ -61,8 +68,48 @@ async function launchCwd(launch) {
         throw new Error("Akuma wake has no born soul");
     return (await turnRecipe(launch.paths, soul)).cwd;
 }
+function parseSchemaAnswerJson(raw) {
+    try {
+        JSON.parse(raw);
+        return { kind: "json", json: raw };
+    }
+    catch (error) {
+        return {
+            kind: "invalid",
+            diagnostic: error instanceof Error ? error.message : "Answer is not valid JSON",
+        };
+    }
+}
 async function persistTurn(paths, turnSequence, result, completedAt) {
+    const turn = await readTurn(paths, turnSequence);
+    const schemaJson = turn?.schemaJson;
     if (result.kind === "answered" && result.session !== undefined) {
+        if (schemaJson !== undefined) {
+            const parsed = parseSchemaAnswerJson(result.answer);
+            if (parsed.kind === "invalid") {
+                const outcome = {
+                    kind: "invalid-output",
+                    diagnostic: parsed.diagnostic,
+                    answer: result.answer,
+                    session: result.session,
+                    ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
+                };
+                await endTurn(paths, { turnSequence, outcome, completedAt });
+                return { outcome: "failed", diagnostic: parsed.diagnostic };
+            }
+            await endTurn(paths, {
+                turnSequence,
+                outcome: {
+                    kind: "answered",
+                    session: result.session,
+                    answer: result.answer,
+                    answerJson: parsed.json,
+                    ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
+                },
+                completedAt,
+            });
+            return { outcome: "answered", answer: result.answer };
+        }
         await endTurn(paths, {
             turnSequence,
             outcome: {
@@ -79,52 +126,24 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
     await endTurn(paths, { turnSequence, outcome: { kind: "failed", diagnostic }, completedAt });
     return { outcome: "failed", diagnostic };
 }
-function completionMessage(identity, completion) {
-    const participant = completion?.participantName;
-    const contract = completion?.contractId;
-    const header = [identity, participant === undefined ? undefined : `(@${participant})`, contract]
-        .filter((value) => value !== undefined)
-        .join(" ");
-    return `${header}\n✓ came back`;
-}
 function boundedDiagnostic(error) {
     const text = diagnostic(error);
     return text.length <= 500 ? text : `${text.slice(0, 500)}...`;
 }
-async function expressInitialOutcome(launch) {
+async function recordPluginDiagnostic(paths, occurrence, error) {
     try {
-        const { Square } = await import("@astrosheep/square");
-        const identity = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
-        if (identity === undefined)
-            return;
-        const square = await Square.at({ path: keiyakuSquarePath(worldRootForAkumaPaths(launch.paths)) });
-        try {
-            const joined = await square.implicitJoin(identity);
-            if (joined.state === "done" || joined.participant === undefined)
-                return;
-            await joined.participant.express(completionMessage(identity, launch.completion));
-        }
-        finally {
-            await square.close();
-        }
+        await appendFile(paths.log, `plugin ${occurrence} failed: ${boundedDiagnostic(error)}\n`);
     }
-    catch (error) {
-        try {
-            await appendFile(launch.paths.log, `square outcome express failed: ${boundedDiagnostic(error)}\n`);
-        }
-        catch {
-            /* express loss never changes Heart truth */
-        }
+    catch {
+        /* plugin diagnostic loss never changes Heart truth */
     }
 }
-function defaultRuntime() {
-    return {
-        now: () => new Date().toISOString(),
-        spawnChild: spawnAkumaBody,
-        commands: {},
-        spawnBody: spawnAkumaBody,
-    };
-}
+const DEFAULT_RUNTIME = {
+    now: () => new Date().toISOString(),
+    spawnChild: spawnAkumaBody,
+    externalCommands: {},
+    spawnBody: spawnAkumaBody,
+};
 export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
     const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
     const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
@@ -172,11 +191,40 @@ async function recoverBodyRequests(input) {
     }
     return false;
 }
+function turnOutcomeEmitter(launch, soul) {
+    let plugins;
+    const reportDiagnostic = (message) => {
+        void recordPluginDiagnostic(launch.paths, "turn outcome", message);
+    };
+    return (turnSequence, outcome) => {
+        void (async () => {
+            try {
+                plugins ??= pluginRuntime({
+                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
+                    reportDiagnostic,
+                });
+                (await plugins).emit({
+                    kind: "akuma.turn-outcome",
+                    akumaId: soul.id,
+                    turnSequence,
+                    outcome: outcome.outcome === "answered"
+                        ? { kind: "answered", text: outcome.answer }
+                        : { kind: "failed", reason: outcome.diagnostic },
+                    ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
+                }, reportDiagnostic);
+            }
+            catch (error) {
+                await recordPluginDiagnostic(launch.paths, "turn outcome", error);
+            }
+        })();
+    };
+}
 async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime } = input;
     let initial = launch.initialBody;
+    const emitTurnOutcome = turnOutcomeEmitter(launch, soul);
     for (;;) {
-        const launchTells = supervisor.current().pending;
+        const launchTells = drainPendingTells(supervisor.current().pending);
         if (supervisor.signal.aborted) {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -201,28 +249,32 @@ async function runBodyTurns(input) {
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
-            ...(runtime.upstream === undefined ? {} : { upstream: runtime.upstream }),
-            commands: runtime.commands,
+            ...(launchTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson === undefined
+                ? {}
+                : { schemaJson: launchTells.find((tell) => tell.schemaJson !== undefined).schemaJson }),
+            world: runtime.world,
+            externalCommands: runtime.externalCommands,
             now: runtime.now,
         });
-        if (result.kind === "hung")
+        if (result.kind === "hung") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, "Body hung with open bound Turns", runtime.now());
             return;
+        }
         if (result.kind === "stopped") {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
         }
-        if (result.kind === "handoff") {
-            await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
-            return;
-        }
+        if (result.kind === "handoff")
+            return "handoff";
         if (result.kind === "resume-unsupported") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, "resume-unsupported with open bound Turns", runtime.now());
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }
         const outcome = await persistTurn(launch.paths, result.turnSequence, result, runtime.now());
-        if (initial !== undefined)
-            await expressInitialOutcome(launch);
+        emitTurnOutcome(result.turnSequence, outcome);
         if (outcome.outcome === "failed") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, outcome.diagnostic, runtime.now());
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }
@@ -230,24 +282,115 @@ async function runBodyTurns(input) {
         initial = undefined;
     }
 }
-export async function handoffPendingTells(paths, spawn = spawnAkumaBody) {
+async function projectUndeliveredPendingTellEvidence(paths, error) {
     try {
-        if ((await readHeart(paths)).pending.length === 0)
-            return;
-        (await spawn({ paths, refuseIfHeld: true })).release();
+        await appendFile(paths.log, `pending Tell disposition undelivered: ${boundedDiagnostic(error)}\n`);
     }
     catch {
-        /* a later Heart interaction retries the unchanged pending Tell */
+        /* log evidence loss never changes Heart truth */
+    }
+}
+async function settleUndeliveredDisposition(paths, disposition, error) {
+    await projectUndeliveredPendingTellEvidence(paths, error);
+    if (!(await heartExists(paths)))
+        return;
+    const at = new Date().toISOString();
+    await recordUndeliveredPendingTells(paths, at, disposition.tellIds);
+    await resolvePendingTellDisposition(paths, disposition.bodySequence, at);
+}
+async function consumeProvenDisposition(paths, disposition) {
+    const proof = await provePendingTellDispositionCustody(paths, disposition);
+    if (proof.kind !== "proven")
+        return false;
+    await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
+    return true;
+}
+/**
+ * Wait for Heart custody proof of the frozen Tell-id snapshot, or for the
+ * spawned child to exit without that proof. Sequence growth, spawn resolution,
+ * and an unqualified held leash never consume the disposition.
+ */
+async function awaitDispositionCustody(paths, disposition, child, schedule) {
+    for (;;) {
+        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+            child.release();
+            return { kind: "proven" };
+        }
+        const timerController = new AbortController();
+        const timer = schedule(WAKE_REREAD_MS, timerController.signal).then(() => ({ kind: "timer" }));
+        let winner;
+        try {
+            winner = await Promise.race([child.exited.then((exit) => ({ kind: "exited", exit })), timer]);
+        }
+        catch (error) {
+            timerController.abort();
+            await timer.catch(() => undefined);
+            throw error;
+        }
+        if (winner.kind === "timer")
+            continue;
+        timerController.abort();
+        await timer.catch(() => undefined);
+        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+            child.release();
+            return { kind: "proven" };
+        }
+        return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
+    }
+}
+async function resolveDecidedPendingTellDisposition(paths, disposition, spawn) {
+    try {
+        if (await consumeProvenDisposition(paths, disposition))
+            return;
+        const wake = await awaitDispositionCustody(paths, disposition, await spawn({ paths, refuseIfHeld: true }), abortableDelay);
+        if (wake.kind === "proven") {
+            await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
+            return;
+        }
+        // Predecessor still holds the leash: leave the Heart disposition open.
+        if (wake.kind === "held")
+            return;
+        await settleUndeliveredDisposition(paths, disposition, wake.kind === "failed" ? wake.diagnostic : "successor custody unproven");
+    }
+    catch (error) {
+        await settleUndeliveredDisposition(paths, disposition, error);
+    }
+}
+export async function handoffPendingTells(paths, spawn = spawnAkumaBody) {
+    const open = await readOpenPendingTellDisposition(paths);
+    if (open !== null) {
+        await resolveDecidedPendingTellDisposition(paths, open, spawn);
+        return;
     }
+    const before = await readHeart(paths);
+    if (before.pending.length === 0)
+        return;
+    if ((await probeLeash(paths)) === "held")
+        return;
+    const bodySequence = before.latestBody?.sequence;
+    if (bodySequence === undefined || before.latestBody?.end === undefined)
+        return;
+    const decided = await decidePendingTellDisposition(paths, {
+        bodySequence,
+        at: new Date().toISOString(),
+        handoff: before.latestBody.end === "put-down",
+    });
+    if (decided === null)
+        return;
+    await resolveDecidedPendingTellDisposition(paths, decided, spawn);
 }
-export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()) {
+export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
+    const world = runtimeInput.world ?? (await World.at(worldRootForAkumaPaths(launch.paths)));
+    const runtime = { ...DEFAULT_RUNTIME, ...runtimeInput, world };
     const acquired = await takeLeash(launch.paths, launch.refuseIfHeld);
     if (acquired === "held")
         return "held";
     if (acquired === "absent")
         return;
     const leash = acquired;
-    let bodyStarted = false;
+    let pendingTellDisposition = undefined;
+    let bodySequence;
+    let decidedDisposition = null;
     try {
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
@@ -261,12 +404,12 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         if (!(await prepareBodyStart(launch.paths, leash)))
             return;
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
-        bodyStarted = true;
+        bodySequence = body.sequence;
         const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);
         const execution = { launch, soul, adapter: selected, bodySequence: body.sequence, supervisor, runtime };
         try {
             if (await recoverBodyRequests(execution))
-                await runBodyTurns(execution);
+                pendingTellDisposition = await runBodyTurns(execution);
         }
         finally {
             await supervisor.close();
@@ -287,16 +430,33 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         throw error;
     }
     finally {
+        if (bodySequence !== undefined && (await heartExists(launch.paths))) {
+            const body = (await readHeart(launch.paths)).latestBody;
+            const inert = body?.sequence === bodySequence && (body.end !== undefined || body.hung !== undefined);
+            if (inert) {
+                await failOpenBoundTurns(launch.paths, {
+                    bodySequence,
+                    diagnostic: body.hung?.diagnostic ?? `Body ${body.end ?? "ended"} with open bound Turns`,
+                    completedAt: runtime.now(),
+                });
+            }
+            decidedDisposition = await decidePendingTellDisposition(launch.paths, {
+                bodySequence,
+                at: runtime.now(),
+                handoff: pendingTellDisposition === "handoff",
+            });
+        }
         leash.release();
-        if (bodyStarted)
-            await handoffPendingTells(launch.paths, runtime.spawnBody ?? spawnAkumaBody);
+        if (decidedDisposition !== null) {
+            await resolveDecidedPendingTellDisposition(launch.paths, decidedDisposition, runtime.spawnBody ?? spawnAkumaBody);
+        }
     }
 }
 export async function spawnAkumaBody(launch) {
     return await spawnDetachedProcess(await bodyProcessInput(launch));
 }
-export async function runAkumaBody(launch, upstream, commands) {
-    return await driveAkumaBody(launch, undefined, { ...defaultRuntime(), upstream, commands });
+export async function runAkumaBody(launch, world, externalCommands) {
+    return await driveAkumaBody(launch, undefined, { world, externalCommands });
 }
 const DIRECT_TELL_WAKE = {
     spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),

package/build/src/akuma/call-input.d.ts

@@ -0,0 +1,4 @@
+export declare function callReadonly(value: unknown, diagnostic?: string): Readonly<{
+    readonly?: true;
+}>;
+export declare function canonicalBirthCwd(input: string, diagnostic?: string): Promise<string>;

package/build/src/akuma/call-input.js

@@ -0,0 +1,21 @@
+import { realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+export function callReadonly(value, diagnostic = "Akuma call readonly must be true") {
+    if (value === undefined)
+        return {};
+    if (value !== true)
+        throw new TypeError(diagnostic);
+    return { readonly: true };
+}
+export async function canonicalBirthCwd(input, diagnostic = `cwd is not an existing directory: ${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(diagnostic);
+    }
+}

package/build/src/akuma/call-request.d.ts

@@ -1,6 +1,6 @@
 import { type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import { type ErasedRequestCommand, type RequestCommand } from "./request-wire.js";
+import { type ChildRequestCommand, type ErasedRequestCommand, type RequestProtocol } from "./request-wire.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 import { z } from "zod";
 import { type WorldRoot } from "../world.js";
@@ -59,19 +59,16 @@ export type AkumaCallRequestChildLaunch = Readonly<{
     seed: Omit<Soul, "createdAt">;
     initialBody: string;
 }>;
-type CallExecutionContext = Readonly<{
-    id: string;
-    requester: string;
-    signal: AbortSignal;
+type AkumaCallRequestCapabilities = Readonly<{
     world: WorldRoot;
     paths: AkumaPaths;
     parent: Soul;
     spawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
-    admissionOpen(): boolean;
 }>;
 export declare function decodeAkumaCallRequest(value: unknown): AkumaCallRequest | null;
-export declare function akumaCallRequestCommand(): RequestCommand<AkumaCallRequest, AkuId, never, AkuId, CallExecutionContext>;
-export declare function akumaCallRequestCommands(): Readonly<Record<"akuma.call", ErasedRequestCommand>>;
+export declare function akumaCallRequestProtocol(): RequestProtocol<AkumaCallRequest, AkuId, AkuId>;
+export declare function akumaCallRequestCommand(capabilities: AkumaCallRequestCapabilities): ChildRequestCommand<AkumaCallRequest, AkuId, AkuId>;
+export declare function akumaCallRequestCommands(capabilities: AkumaCallRequestCapabilities): Readonly<Record<"akuma.call", ErasedRequestCommand>>;
 export declare function requestForwardedAkumaCall(input: Omit<AkumaCallRequest, "action"> & Readonly<{
     directory: string;
     id: string;

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

@@ -6,7 +6,7 @@ import { publishAkuma } from "./publication.js";
 import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
 import { decodeProviderExecution } from "./providers/index.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
-import { eraseRequestCommand } from "./request-wire.js";
+import { eraseRequestCommand, } from "./request-wire.js";
 import { z } from "zod";
 import { World } from "../world.js";
 function schemaDecode(decode, message) {
@@ -71,49 +71,6 @@ const akumaCallPayloadSchema = z
     recipe: akumaCallRecipeSchema,
 })
     .strict();
-function carriesLaunchWorld(value) {
-    const upstream = object(value);
-    return upstream !== null && typeof upstream.launchWorld === "function";
-}
-function decodeCallExecutionContext(value) {
-    const context = object(value);
-    const paths = object(context?.paths);
-    const parent = object(context?.parent);
-    const parentId = akuIdSchema.safeParse(parent?.id);
-    if (context === null ||
-        typeof context.id !== "string" ||
-        context.id.trim() === "" ||
-        typeof context.requester !== "string" ||
-        typeof context.signal !== "object" ||
-        context.signal === null ||
-        typeof context.signal.throwIfAborted !== "function" ||
-        paths === null ||
-        !["directory", "heart", "leash", "log", "requests"].every((key) => typeof paths[key] === "string") ||
-        parent === null ||
-        !parentId.success ||
-        typeof parent.cwd !== "string" ||
-        !Array.isArray(parent.allowed) ||
-        typeof context.spawn !== "function" ||
-        typeof context.admissionOpen !== "function")
-        throw new Error("invalid Akuma call execution context");
-    if (!carriesLaunchWorld(context.upstream))
-        throw new Error("Akuma call requires a minted launch World");
-    return {
-        id: context.id,
-        requester: context.requester,
-        signal: context.signal,
-        world: context.upstream.launchWorld(),
-        paths: context.paths,
-        parent: context.parent,
-        spawn: context.spawn,
-        admissionOpen: context.admissionOpen,
-    };
-}
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
 export function decodeAkumaCallRequest(value) {
     const parsed = akumaCallPayloadSchema.safeParse(value);
     return parsed.success ? { ...parsed.data, action: "akuma.call" } : null;
@@ -122,16 +79,16 @@ function callPayload(request) {
     const { action: _action, ...payload } = request;
     return payload;
 }
-async function executeAkumaCall(request, context) {
-    const world = context.world;
+async function executeAkumaCall(request, facts, capabilities) {
+    const { world, paths, parent, spawn } = capabilities;
     const requestWorld = await World.prove(request.world);
     if (requestWorld !== world) {
-        await refuseRequest(context.paths, context.id, `request world ${requestWorld} does not match ${world}`);
+        await refuseRequest(paths, facts.id, `request world ${requestWorld} does not match ${world}`);
         throw new Error(`request world ${requestWorld} does not match ${world}`);
     }
     const recipe = {
         ...(request.recipe.description === undefined ? {} : { description: request.recipe.description }),
-        allowed: clipAllowedActions(request.recipe.allowed, context.parent.allowed),
+        allowed: clipAllowedActions(request.recipe.allowed, parent.allowed),
         provider: request.recipe.provider,
         options: request.recipe.options,
         ...(request.recipe.readonly === undefined ? {} : { readonly: request.recipe.readonly }),
@@ -139,19 +96,19 @@ async function executeAkumaCall(request, context) {
     const published = await publishAkuma({
         worldPath: world,
         archetype: request.archetype,
-        signal: context.signal,
+        signal: facts.signal,
         launch: async (allocated) => {
-            if (!context.admissionOpen())
+            if (!facts.admissionOpen())
                 throw new Error("body closed request admission");
-            await reserveRequest(context.paths, context.id, allocated.id);
-            return await context.spawn({
+            await reserveRequest(paths, facts.id, allocated.id);
+            return await spawn({
                 paths: allocated.paths,
                 seed: {
                     id: allocated.id,
                     archetype: allocated.archetype,
                     ...recipe,
-                    cwd: request.cwd ?? context.parent.cwd,
-                    origin: { kind: "request", parent: context.parent.id, requestId: context.id },
+                    cwd: request.cwd ?? parent.cwd,
+                    origin: { kind: "request", parent: parent.id, requestId: facts.id },
                 },
                 initialBody: request.body,
             });
@@ -159,7 +116,7 @@ async function executeAkumaCall(request, context) {
     });
     return { result: published.id, child: published.id };
 }
-export function akumaCallRequestCommand() {
+export function akumaCallRequestProtocol() {
     return {
         action: "akuma.call",
         encodeRequest: callPayload,
@@ -171,19 +128,6 @@ export function akumaCallRequestCommand() {
                 throw new Error("Akuma call returned an invalid child");
             return child.data;
         },
-        encodeService: (service) => service,
-        decodeService: (_service) => {
-            throw new Error("Akuma call has no service evidence");
-        },
-        projectService: (_service) => {
-            throw new Error("Akuma call has no service evidence");
-        },
-        projectChild: (child) => {
-            const id = akuIdSchema.safeParse(child);
-            if (!id.success)
-                throw new Error("Akuma call stored an invalid child reference");
-            return id.data;
-        },
         decodeReference: (reference) => {
             const child = akuIdSchema.safeParse(reference);
             if (!child.success)
@@ -191,19 +135,30 @@ export function akumaCallRequestCommand() {
             return child.data;
         },
         isPermitted: (allowed) => allowed.includes("akuma.call"),
-        decodeExecutionContext: decodeCallExecutionContext,
-        execute: executeAkumaCall,
     };
 }
-export function akumaCallRequestCommands() {
-    return { "akuma.call": eraseRequestCommand(akumaCallRequestCommand()) };
+export function akumaCallRequestCommand(capabilities) {
+    return {
+        completion: "child",
+        protocol: akumaCallRequestProtocol(),
+        projectChild: (child) => {
+            const id = akuIdSchema.safeParse(child);
+            if (!id.success)
+                throw new Error("Akuma call stored an invalid child reference");
+            return id.data;
+        },
+        execute: async (request, facts) => await executeAkumaCall(request, facts, capabilities),
+    };
+}
+export function akumaCallRequestCommands(capabilities) {
+    return { "akuma.call": eraseRequestCommand(akumaCallRequestCommand(capabilities)) };
 }
 export async function requestForwardedAkumaCall(input) {
     const { directory, id, signal, ...request } = input;
     const response = await requestBodyCommand({
         directory,
         id,
-        command: akumaCallRequestCommand(),
+        command: akumaCallRequestProtocol(),
         value: { ...request, action: "akuma.call" },
         ...(signal === undefined ? {} : { signal }),
     });

package/build/src/akuma/fleet-execution.d.ts

@@ -0,0 +1,26 @@
+import { type AkumaStatus } from "./akuma.js";
+import type { WorldRoot } from "../world.js";
+import { type AkumaKillResult, type AkumaTellResult, type AkumaWaitResult } from "./fleet-observation.js";
+export type WaitExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    completion: "any" | "all";
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}>;
+export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
+export type TellExecutionInput = Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    body: string;
+    tellId?: string;
+    recordedAt?: string;
+    signal?: AbortSignal;
+}>;
+export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
+export type KillExecutionInput = Readonly<{
+    path: WorldRoot;
+    ids: readonly AkumaStatus["id"][];
+    signal?: AbortSignal;
+}>;
+export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;