@astrosheep/keiyaku 4.5.7 → 4.5.8

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,373 @@ 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.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.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.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.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 +400,7 @@ export type UnbornAkumaListRow = Readonly<{
     }>;
 }>;
 export type AkumaList = Readonly<{
+    observedAt: string;
     rows: readonly (AkumaListRow | UnbornAkumaListRow)[];
     searched: readonly string[];
 }>;
@@ -108,6 +470,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/body.d.ts

@@ -1,7 +1,8 @@
+import type { AkumaCallRequestChildLaunch } from "./call-request.js";
 import { type SessionFact, type Soul } 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";
@@ -45,9 +46,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 +62,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

@@ -7,7 +7,7 @@ import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHe
 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 }),

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

@@ -0,0 +1,80 @@
+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 { OwnedProcess } from "../runtime/proc/run.js";
+import { z } from "zod";
+import { type WorldRoot } from "../world.js";
+declare const akumaCallRecipeSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
+    provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        name: string;
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        executable?: string;
+        config?: Readonly<Record<string, unknown>>;
+        env?: Readonly<Record<string, string>>;
+    }>, unknown>>;
+    options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        model?: string;
+        effort?: string;
+        readonly?: true;
+        network?: "disabled" | "enabled";
+        systemPrompt?: string;
+        systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
+    }>, unknown>>;
+    readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
+}, z.core.$strict>;
+declare const akumaCallPayloadSchema: z.ZodObject<{
+    world: z.ZodString;
+    archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    body: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    recipe: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        allowed: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./allowed.js").AllowedActions, unknown>>;
+        provider: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+            name: string;
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            executable?: string;
+            config?: Readonly<Record<string, unknown>>;
+            env?: Readonly<Record<string, string>>;
+        }>, unknown>>;
+        options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+            model?: string;
+            effort?: string;
+            readonly?: true;
+            network?: "disabled" | "enabled";
+            systemPrompt?: string;
+            systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
+        }>, unknown>>;
+        readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type AkumaCallRecipe = z.infer<typeof akumaCallRecipeSchema>;
+export type AkumaCallRequest = z.infer<typeof akumaCallPayloadSchema> & Readonly<{
+    action: "akuma.call";
+}>;
+export type AkumaCallRequestChildLaunch = Readonly<{
+    paths: AkumaPaths;
+    seed: Omit<Soul, "createdAt">;
+    initialBody: string;
+}>;
+type CallExecutionContext = Readonly<{
+    id: string;
+    requester: string;
+    signal: AbortSignal;
+    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 requestForwardedAkumaCall(input: Omit<AkumaCallRequest, "action"> & Readonly<{
+    directory: string;
+    id: string;
+    signal?: AbortSignal;
+}>): Promise<AkuId>;
+export {};