@astrosheep/keiyaku 4.5.6 → 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";
@@ -40,14 +41,15 @@ export type TellResult = Readonly<{
     wake: TellWake;
 }>;
 export type TellWakeRuntime = Readonly<{
-    observeHeart(paths: AkumaPaths, signal: AbortSignal): Promise<AsyncGenerator<void>>;
     spawn(paths: AkumaPaths): Promise<OwnedProcess>;
+    schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;
 }>;
 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

@@ -3,13 +3,14 @@ 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, watchHeart, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, 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;
 export const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
@@ -120,6 +121,7 @@ function defaultRuntime() {
     return {
         now: () => new Date().toISOString(),
         spawnChild: spawnAkumaBody,
+        commands: {},
         spawnBody: spawnAkumaBody,
     };
 }
@@ -200,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")
@@ -292,12 +295,12 @@ 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 = {
-    observeHeart: watchHeart,
     spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),
+    schedule: abortableDelay,
 };
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -321,61 +324,47 @@ function failedChild(exit) {
         child: { code: exit.code, signal: exit.signal, log: exit.log },
     };
 }
-async function awaitWake(paths, tellId, after, child, changed) {
-    let nextChange = changed.next();
+async function awaitWake(paths, tellId, after, child, schedule) {
     for (;;) {
         const settled = await settledWake(paths, tellId, after);
         if (settled !== null) {
             child.release();
             return settled;
         }
-        const winner = await Promise.race([
-            nextChange.then(({ done }) => ({ kind: done ? "closed" : "changed" }), (error) => ({ kind: "observer-failed", error })),
-            child.exited.then((exit) => ({ kind: "exited", exit })),
-        ]);
-        if (winner.kind === "changed") {
-            nextChange = changed.next();
-            continue;
+        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);
         const final = await settledWake(paths, tellId, after);
         if (final !== null) {
             child.release();
             return final;
         }
-        if (winner.kind === "exited") {
-            return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
-        }
-        try {
-            await child.terminate();
-        }
-        catch (error) {
-            /* Termination rejection leaves physical custody unresolved; release it deliberately. */
-            child.release();
-            return { kind: "failed", diagnostic: diagnostic(error) };
-        }
-        return winner.kind === "observer-failed"
-            ? { kind: "failed", diagnostic: diagnostic(winner.error) }
-            : { kind: "failed", diagnostic: "Heart observer closed" };
+        return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
     }
 }
 async function wakePendingTells(paths, tellId, runtime) {
-    const watching = new AbortController();
-    let changed;
     try {
-        changed = await runtime.observeHeart(paths, watching.signal);
         const beforeHeart = await readHeart(paths);
         if (tellId === undefined && beforeHeart.pending.length === 0)
             return null;
         const before = beforeHeart.latestBody?.sequence ?? 0;
-        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), changed);
+        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), runtime.schedule ?? abortableDelay);
     }
     catch (error) {
         return { kind: "failed", diagnostic: diagnostic(error) };
     }
-    finally {
-        watching.abort();
-        await changed?.return(undefined);
-    }
 }
 export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE) {
     return {