@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -1,10 +1,11 @@
 import { type TellResult, type TellWakeRuntime } from "./body.js";
-import { HeldAkumaLeash, type AkumaLife, type KillEvidence, type ResumeCoordinate, type Soul } from "./heart/index.js";
+import { HeldAkumaLeash, type AkumaLife, type KillEvidence, type ResumeCoordinate } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
-import type { ActivitySnapshot } from "./projection.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
 import type { AllowedAction } from "./allowed.js";
+import type { ExecutionContext } from "./requests.js";
+import { z } from "zod";
 export declare const POLL_MS = 100;
 export declare function canonicalBirthCwd(input: string): Promise<string>;
 export declare function callReadonly(value: unknown): Readonly<{
@@ -19,13 +20,393 @@ export type AkumaListRow = Readonly<{
     lastActivityAt: string | null;
     pending: readonly string[];
 }>;
-export type AkumaStatus = Readonly<{
-    id: AkuId;
-    life: AkumaLife;
-    readonly?: Soul["readonly"];
-    timeline: ActivitySnapshot;
-    strandedReason?: "resume-unsupported";
-}>;
+export declare const akumaIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+export declare const akumaStatusSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    life: z.ZodEnum<{
+        killed: "killed";
+        hung: "hung";
+        untidy: "untidy";
+        running: "running";
+        asleep: "asleep";
+        stranded: "stranded";
+    }>;
+    readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        enforcement: z.ZodLiteral<"native">;
+    }, z.core.$strict>, z.ZodObject<{
+        enforcement: z.ZodLiteral<"none">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>>;
+    timeline: z.ZodUnion<readonly [z.ZodObject<{
+        reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            at: z.ZodString;
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        reportedChangesOmitted: z.ZodNumber;
+        kind: z.ZodLiteral<"unborn">;
+        entries: z.ZodReadonly<z.ZodTuple<[], null>>;
+        omitted: z.ZodLiteral<0>;
+    }, z.core.$strict>, z.ZodObject<{
+        reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            at: z.ZodString;
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        reportedChangesOmitted: z.ZodNumber;
+        kind: z.ZodLiteral<"open">;
+        turn: z.ZodObject<{
+            kind: z.ZodLiteral<"turn">;
+            sequence: z.ZodNumber;
+            turnSequence: z.ZodNumber;
+            bodySequence: z.ZodNumber;
+            at: z.ZodString;
+        }, z.core.$strict>;
+        entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"gap">;
+            count: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"row">;
+            row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"call">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"tell">;
+                sequence: z.ZodNumber;
+                at: z.ZodString;
+                tellId: z.ZodString;
+                text: z.ZodString;
+                state: z.ZodEnum<{
+                    pending: "pending";
+                    told: "told";
+                }>;
+                deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                    deliveredAt: z.ZodString;
+                    route: z.ZodEnum<{
+                        live: "live";
+                        launch: "launch";
+                    }>;
+                    turnSequence: z.ZodNumber;
+                    receipt: z.ZodOptional<z.ZodEnum<{
+                        required: "required";
+                        unavailable: "unavailable";
+                    }>>;
+                }, z.core.$strict>, z.ZodTransform<Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>, {
+                    deliveredAt: string;
+                    route: "live" | "launch";
+                    turnSequence: number;
+                    receipt?: "required" | "unavailable" | undefined;
+                }>>>>;
+            }, z.core.$strict>]>, z.ZodObject<{
+                kind: z.ZodLiteral<"tool">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                name: z.ZodString;
+                call: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"run">;
+                    command: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"read">;
+                    path: z.ZodString;
+                    offset: z.ZodOptional<z.ZodNumber>;
+                    limit: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"search">;
+                    query: z.ZodString;
+                    scope: z.ZodOptional<z.ZodEnum<{
+                        content: "content";
+                        files: "files";
+                        web: "web";
+                    }>>;
+                    path: z.ZodOptional<z.ZodString>;
+                    glob: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fileChange">;
+                    changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            add: "add";
+                            update: "update";
+                            delete: "delete";
+                            unspecified: "unspecified";
+                        }>;
+                        path: z.ZodString;
+                        diffstat: z.ZodOptional<z.ZodObject<{
+                            added: z.ZodNumber;
+                            removed: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"other">;
+                    display: z.ZodString;
+                }, z.core.$strict>]>;
+                state: z.ZodLiteral<"active">;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"tool">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                completedAt: z.ZodOptional<z.ZodString>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodString;
+                call: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"run">;
+                    command: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"read">;
+                    path: z.ZodString;
+                    offset: z.ZodOptional<z.ZodNumber>;
+                    limit: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"search">;
+                    query: z.ZodString;
+                    scope: z.ZodOptional<z.ZodEnum<{
+                        content: "content";
+                        files: "files";
+                        web: "web";
+                    }>>;
+                    path: z.ZodOptional<z.ZodString>;
+                    glob: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fileChange">;
+                    changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            add: "add";
+                            update: "update";
+                            delete: "delete";
+                            unspecified: "unspecified";
+                        }>;
+                        path: z.ZodString;
+                        diffstat: z.ZodOptional<z.ZodObject<{
+                            added: z.ZodNumber;
+                            removed: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"other">;
+                    display: z.ZodString;
+                }, z.core.$strict>]>;
+                state: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        error: "error";
+                        ok: "ok";
+                    }>;
+                    message: z.ZodOptional<z.ZodString>;
+                    exitCode: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>]>>>;
+        omitted: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            sequence: z.ZodNumber;
+            at: z.ZodString;
+            op: z.ZodEnum<{
+                add: "add";
+                update: "update";
+                delete: "delete";
+                unspecified: "unspecified";
+            }>;
+            path: z.ZodString;
+            diffstat: z.ZodOptional<z.ZodObject<{
+                added: z.ZodNumber;
+                removed: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        reportedChangesOmitted: z.ZodNumber;
+        kind: z.ZodLiteral<"idle">;
+        outcome: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"outcome">;
+            sequence: z.ZodNumber;
+            turnSequence: z.ZodNumber;
+            at: z.ZodString;
+            outcome: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"answered">;
+                historyId: z.ZodString;
+                answer: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"failed">;
+                historyId: z.ZodString;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>;
+        entries: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"gap">;
+            count: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"row">;
+            row: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"call">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"note" | "thought" | "said">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                text: z.ZodString;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"tell">;
+                sequence: z.ZodNumber;
+                at: z.ZodString;
+                tellId: z.ZodString;
+                text: z.ZodString;
+                state: z.ZodEnum<{
+                    pending: "pending";
+                    told: "told";
+                }>;
+                deliveries: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodObject<{
+                    deliveredAt: z.ZodString;
+                    route: z.ZodEnum<{
+                        live: "live";
+                        launch: "launch";
+                    }>;
+                    turnSequence: z.ZodNumber;
+                    receipt: z.ZodOptional<z.ZodEnum<{
+                        required: "required";
+                        unavailable: "unavailable";
+                    }>>;
+                }, z.core.$strict>, z.ZodTransform<Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>, {
+                    deliveredAt: string;
+                    route: "live" | "launch";
+                    turnSequence: number;
+                    receipt?: "required" | "unavailable" | undefined;
+                }>>>>;
+            }, z.core.$strict>]>, z.ZodObject<{
+                kind: z.ZodLiteral<"tool">;
+                sequence: z.ZodNumber;
+                turnSequence: z.ZodNumber;
+                at: z.ZodString;
+                completedAt: z.ZodOptional<z.ZodString>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodString;
+                call: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"run">;
+                    command: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"read">;
+                    path: z.ZodString;
+                    offset: z.ZodOptional<z.ZodNumber>;
+                    limit: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"search">;
+                    query: z.ZodString;
+                    scope: z.ZodOptional<z.ZodEnum<{
+                        content: "content";
+                        files: "files";
+                        web: "web";
+                    }>>;
+                    path: z.ZodOptional<z.ZodString>;
+                    glob: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"fileChange">;
+                    changes: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            add: "add";
+                            update: "update";
+                            delete: "delete";
+                            unspecified: "unspecified";
+                        }>;
+                        path: z.ZodString;
+                        diffstat: z.ZodOptional<z.ZodObject<{
+                            added: z.ZodNumber;
+                            removed: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"other">;
+                    display: z.ZodString;
+                }, z.core.$strict>]>;
+                state: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        error: "error";
+                        ok: "ok";
+                    }>;
+                    message: z.ZodOptional<z.ZodString>;
+                    exitCode: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>]>>>;
+        omitted: z.ZodNumber;
+    }, z.core.$strict>]>;
+    strandedReason: z.ZodOptional<z.ZodLiteral<"resume-unsupported">>;
+}, z.core.$strict>;
+export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
+export declare function parseAkumaStatus(value: unknown): AkumaStatus;
 /** The default completion judgment over one complete status snapshot. */
 export declare function defaultWaitComplete(status: AkumaStatus): boolean;
 export type { ReadonlyRestraint } from "./provider-recipe.js";
@@ -39,6 +420,7 @@ export type UnbornAkumaListRow = Readonly<{
     }>;
 }>;
 export type AkumaList = Readonly<{
+    observedAt: string;
     rows: readonly (AkumaListRow | UnbornAkumaListRow)[];
     searched: readonly string[];
 }>;
@@ -108,6 +490,7 @@ export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, type B
 export type AkumaConfiguration = Readonly<{
     home?: string;
     settings?: Settings;
+    execution?: ExecutionContext;
 }>;
 export { AkumaHandle, akumaCallExecution, type LastAnswer } from "./akuma-handle.js";
 export { Akuma, callAkumaWithContext } from "./akuma-product.js";

package/build/src/akuma/akuma.js

@@ -3,7 +3,9 @@ import { realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { CONTROL_RESPONSE_MS, handoffPendingTells, wakeRecordedTell, } from "./body.js";
 import { HeldAkumaLeash, readHeart, readKill, recordTell, requestStop, } from "./heart/index.js";
-import { pathsForAkuId } from "./identity.js";
+import { parseAkuId, pathsForAkuId } from "./identity.js";
+import { activitySnapshotSchema } from "./projection.js";
+import { z } from "zod";
 export const POLL_MS = 100;
 export async function canonicalBirthCwd(input) {
     const selected = resolve(input);
@@ -24,6 +26,34 @@ export function callReadonly(value) {
         throw new TypeError("Akuma call readonly must be true");
     return { readonly: true };
 }
+export const akumaIdSchema = z.string().transform((value, context) => {
+    try {
+        const id = parseAkuId(value).id;
+        if (id !== value)
+            throw new Error("not canonical");
+        return id;
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected canonical AkuId" });
+        return z.NEVER;
+    }
+});
+const readonlySchema = z.union([
+    z.object({ enforcement: z.literal("native") }).strict(),
+    z.object({ enforcement: z.literal("none"), diagnostic: z.string().refine((value) => value.trim() !== "") }).strict(),
+]);
+export const akumaStatusSchema = z
+    .object({
+    id: akumaIdSchema,
+    life: z.enum(["running", "asleep", "stranded", "hung", "untidy", "killed"]),
+    readonly: readonlySchema.optional(),
+    timeline: activitySnapshotSchema,
+    strandedReason: z.literal("resume-unsupported").optional(),
+})
+    .strict();
+export function parseAkumaStatus(value) {
+    return akumaStatusSchema.parse(value);
+}
 /** The default completion judgment over one complete status snapshot. */
 export function defaultWaitComplete(status) {
     return (status.life !== "running" &&

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

@@ -1,4 +1,4 @@
-export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.deliver", "contract.review", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
 export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
 export type AllowedActions = readonly AllowedAction[];
 export declare function isAllowedAction(value: unknown): value is AllowedAction;

package/build/src/akuma/allowed.js

@@ -3,6 +3,7 @@ export const ALLOWED_ACTIONS = Object.freeze([
     "akuma.call",
     "akuma.kill",
     "akuma.tell",
+    "contract.audit",
     "contract.deliver",
     "contract.review",
     ...TASK_MUTATION_ACTIONS,

package/build/src/akuma/archetype.js

@@ -75,7 +75,7 @@ function archetypeReadonly(values) {
 function decodeArchetype(name, path, markdown) {
     const lines = markdown.split(/\r?\n/u);
     if (lines[0]?.trim() !== "---")
-        throw new TypeError("Akuma configuration must begin with YAML frontmatter");
+        throw new TypeError("Akuma file must begin with YAML frontmatter");
     const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
     if (closing < 0)
         throw new TypeError("Akuma frontmatter is not closed");

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

@@ -1,7 +1,8 @@
-import { type SessionFact, type Soul } from "./heart/index.js";
+import type { AkumaCallRequestChildLaunch } from "./call-request.js";
+import { type SessionFact, type Soul, type TellRow } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
 import type { ProviderAdapter } from "./provider.js";
-import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
+import type { ErasedRequestCommand } from "./request-wire.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
@@ -37,6 +38,7 @@ export type TellResult = Readonly<{
         tellId: string;
         fact: "recorded";
     }>;
+    row: TellRow;
     wake: TellWake;
 }>;
 export type TellWakeRuntime = Readonly<{
@@ -45,9 +47,10 @@ export type TellWakeRuntime = Readonly<{
 }>;
 type BodyRuntime = Readonly<{
     now(): string;
-    spawnChild?(launch: RequestChildLaunch): Promise<OwnedProcess>;
+    spawnChild?(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess>;
     spawnBody?(launch: BodyLaunch): Promise<OwnedProcess>;
-    upstream?: UpstreamExecutionPort;
+    upstream?: unknown;
+    commands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
@@ -60,5 +63,5 @@ export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: str
 export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtime?: BodyRuntime): Promise<"held" | void>;
 export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
-export declare function runAkumaBody(launch: BodyLaunch, upstream: UpstreamExecutionPort): Promise<"held" | void>;
+export declare function runAkumaBody(launch: BodyLaunch, upstream: unknown, commands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
 export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime): Promise<TellResult>;

package/build/src/akuma/body.js

@@ -3,11 +3,11 @@ 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, readHeart, readNonterminalRequests, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, projectTell, readHeart, readTell, readNonterminalRequests, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { keiyakuSquarePath } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
-import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
+import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
 const WAKE_REREAD_MS = 100;
@@ -121,6 +121,7 @@ function defaultRuntime() {
     return {
         now: () => new Date().toISOString(),
         spawnChild: spawnAkumaBody,
+        commands: {},
         spawnBody: spawnAkumaBody,
     };
 }
@@ -201,6 +202,7 @@ async function runBodyTurns(input) {
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
             ...(runtime.upstream === undefined ? {} : { upstream: runtime.upstream }),
+            commands: runtime.commands,
             now: runtime.now,
         });
         if (result.kind === "hung")
@@ -293,8 +295,8 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
 export async function spawnAkumaBody(launch) {
     return await spawnDetachedProcess(await bodyProcessInput(launch));
 }
-export async function runAkumaBody(launch, upstream) {
-    return await driveAkumaBody(launch, undefined, { ...defaultRuntime(), upstream });
+export async function runAkumaBody(launch, upstream, commands) {
+    return await driveAkumaBody(launch, undefined, { ...defaultRuntime(), upstream, commands });
 }
 const DIRECT_TELL_WAKE = {
     spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),
@@ -365,8 +367,13 @@ async function wakePendingTells(paths, tellId, runtime) {
     }
 }
 export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE) {
+    const wake = (await wakePendingTells(paths, tellId, runtime));
+    const tell = await readTell(paths, tellId);
+    if (tell === null)
+        throw new Error(`recorded Tell ${tellId} is missing from Heart`);
     return {
         admission: { tellId, fact: "recorded" },
-        wake: (await wakePendingTells(paths, tellId, runtime)),
+        row: projectTell(tell),
+        wake,
     };
 }