@astrosheep/keiyaku 4.6.18 → 4.6.20

package/build/src/akuma/body.js

@@ -1,48 +1,22 @@
 import { projectAkumaBirth } from "./caller.js";
-import { z } from "zod";
-import { decodeSoulSeed } from "./heart/soul.js";
-import { sessionAdmissionSchema } from "./heart/rows.js";
-import { appendFile, stat } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import { abortable, abortableDelay } from "./abort.js";
+import { appendFile } from "node:fs/promises";
+import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
-import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, BodyControlledError, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
-import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
+import { driveTurn } from "./turn-drive.js";
+import { HeldAkumaLeash, BodyControlledError, breakBody, cancelBodyTurns, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
+import { pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { recordAkumaLineage } from "./lineage-cache.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
-import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
 import { emitPluginSignal } from "../plugin/akuma-signals.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";
+import { observeBodyLaunch, launchEndWake, } from "./body-launch.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";
-const launchSeedSchema = z.unknown().transform((value, context) => {
-    try {
-        return decodeSoulSeed(value);
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "invalid Body birth seed" });
-        return z.NEVER;
-    }
-});
-export const bodyLaunchSchema = z
-    .object({
-    paths: akumaPathsSchema,
-    seed: launchSeedSchema.optional(),
-    birthSession: sessionAdmissionSchema.optional(),
-    initialBody: z.string().optional(),
-    initiator: z.string().optional(),
-    birthInitiator: z.string().optional(),
-    initialSchemaJson: z.string().optional(),
-    refuseIfHeld: z.boolean().optional(),
-    completion: z.object({ contractId: z.string().optional() }).strict().optional(),
-})
-    .strict();
+export function tellWakeRuntime(spawn) {
+    return { spawn: async (paths) => await spawn({ paths, refuseIfHeld: true }) };
+}
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
@@ -51,14 +25,19 @@ async function failOpenBoundTurnsIfPresent(paths, bodySequence, diagnostic, at)
         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() });
-    }
+async function putDownBody(paths, bodySequence, now, turnOutcome, handoff = false) {
+    const settled = await cancelBodyTurns(paths, { bodySequence, at: now(), handoff });
+    for (const sequence of settled.canceled)
+        await turnOutcome?.emit(sequence);
+    return settled.disposition ?? undefined;
 }
-async function takeLeash(paths, refuseIfHeld = false) {
+async function putDownIfControlled(paths, supervisor, bodySequence, now, turnOutcome) {
+    if ((supervisor.reason === "control" || supervisor.reason === "launch") && (await heartExists(paths)))
+        await putDownBody(paths, bodySequence, now, turnOutcome);
+}
+async function takeLeash(paths, refuseIfHeld = false, signal) {
     for (;;) {
+        signal?.throwIfAborted();
         try {
             const leash = await HeldAkumaLeash.try(paths);
             if (leash !== null)
@@ -71,7 +50,7 @@ async function takeLeash(paths, refuseIfHeld = false) {
                 return "absent";
             throw error;
         }
-        await abortableDelay(LEASH_RETRY_MS);
+        await abortableDelay(LEASH_RETRY_MS, signal);
     }
 }
 async function bornSoul(launch, leash, now) {
@@ -90,14 +69,6 @@ async function bornSoul(launch, leash, now) {
     }
     return { soul: born, created: result === "born" };
 }
-async function launchCwd(launch) {
-    if (launch.seed !== undefined)
-        return launch.seed.cwd;
-    const soul = (await readHeart(launch.paths)).soul;
-    if (soul === null)
-        throw new Error("Akuma wake has no born soul");
-    return (await turnRecipe(launch.paths, soul)).cwd;
-}
 function parseSchemaAnswerJson(raw) {
     try {
         JSON.parse(raw);
@@ -114,6 +85,7 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
     const turn = await readTurn(paths, turnSequence);
     const schemaJson = turn?.schemaJson;
     if (result.kind === "answered" && result.session !== undefined) {
+        let answerJson;
         if (schemaJson !== undefined) {
             const parsed = parseSchemaAnswerJson(result.answer);
             if (parsed.kind === "invalid") {
@@ -127,18 +99,7 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
                 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 };
+            answerJson = parsed.json;
         }
         await endTurn(paths, {
             turnSequence,
@@ -146,11 +107,12 @@ async function persistTurn(paths, turnSequence, result, completedAt) {
                 kind: "answered",
                 session: result.session,
                 answer: result.answer,
+                ...(answerJson === undefined ? {} : { answerJson }),
                 ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
             },
             completedAt,
         });
-        return { outcome: "answered", answer: result.answer };
+        return { outcome: "answered" };
     }
     const diagnostic = result.kind === "answered" ? "Provider answered without a resumable session" : result.diagnostic;
     await endTurn(paths, { turnSequence, outcome: { kind: "failed", diagnostic }, completedAt });
@@ -168,110 +130,30 @@ export async function recordPluginDiagnostic(paths, occurrence, error) {
         /* plugin diagnostic loss never changes Heart truth */
     }
 }
-const DEFAULT_RUNTIME = {
-    now: () => new Date().toISOString(),
-    spawnChild: spawnAkumaBody,
-    externalCommands: {},
-    spawnBody: spawnAkumaBody,
-};
-/**
- * The Body spawn executable is the waking process's own executable, resolved
- * at use time. There is no recorded path and no re-resolution chain: when the
- * file is genuinely gone the spawn fails honestly and the wake diagnostic
- * names the missing piece.
- */
-async function executableMissing(path) {
-    try {
-        return !(await stat(path)).isFile();
-    }
-    catch {
-        return true;
-    }
-}
-async function frozenCwdMissing(path) {
-    try {
-        await stat(path);
-        return false;
-    }
-    catch {
-        return true;
-    }
-}
-/**
- * Diagnose an ENOENT Body spawn failure by checking the attempted executable
- * and the frozen execution cwd separately. The message names the genuinely
- * missing piece(s) with the kill-and-call-fresh remedy; a missing cwd likely
- * means its Contract was accepted and the worktree cleaned up. When both
- * pieces still exist the original failure passes through unchanged, as does
- * any non-ENOENT spawn failure.
- */
-async function diagnoseSpawnEnoent(input, cause) {
-    const executable = input.argv[0] ?? process.execPath;
-    const cwd = input.cwd;
-    const [noExecutable, noCwd] = await Promise.all([executableMissing(executable), frozenCwdMissing(cwd)]);
-    if (!noExecutable && !noCwd)
-        return cause instanceof Error ? cause : new Error(String(cause));
-    const missing = [];
-    if (noCwd)
-        missing.push(`frozen execution directory ${cwd} no longer exists`);
-    if (noExecutable)
-        missing.push(`waking process executable ${executable} no longer exists (the host likely removed the running process binary)`);
-    const remedies = [];
-    if (noCwd)
-        remedies.push("a missing execution directory likely means its Contract was accepted and the worktree cleaned up, with deliverables already in Git");
-    if (noExecutable)
-        remedies.push("a missing executable likely means the host removed the running process binary: re-enter with a fresh CLI process and retry");
-    const remedy = `kill this Akuma and call a fresh one; ${remedies.join("; ")}`;
-    const error = new Error(`Body spawn failed: ${missing.join(" and ")}; ${remedy}`, { cause });
-    error.code = "ENOENT";
-    return error;
-}
-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;
-    if (actorId === undefined)
-        throw new Error("Akuma wake has no born soul");
-    const executable = process.execPath;
-    const source = bodyModuleUrl.endsWith(".ts");
-    const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
-    return {
-        argv: source ? [executable, "--import", import.meta.resolve("tsx"), entry, encoded] : [executable, entry, encoded],
-        cwd: await launchCwd(launch),
-        env: akumaExecutionEnvironment(process.env, {
-            KEIYAKU_ACTOR_ID: actorId,
-            KEIYAKU_ACTOR_WORLD: worldRootForAkumaPaths(launch.paths),
-        }),
-        log: launch.paths.log,
-    };
-}
 async function prepareBodyExecution(launch, leash, runtime, adapter) {
+    runtime.signal?.throwIfAborted();
     const birth = await bornSoul(launch, leash, runtime.now());
+    runtime.signal?.throwIfAborted();
     if (birth === null)
         return null;
     // The immutable caller edge refreshes after Soul durability, best-effort.
     if (birth.created)
         void recordAkumaLineage(runtime.world, birth.soul);
     const { soul } = birth;
-    if (!(await prepareBodyStart(launch.paths, leash)))
+    if (launch.handoffFromBodySequence === undefined && !(await prepareBodyStart(launch.paths, leash)))
         return null;
     if (launch.seed === undefined && launch.initialBody === undefined) {
         const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
         if (heart.pending.length === 0 && requests.length === 0)
             return null;
     }
+    runtime.signal?.throwIfAborted();
     const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
+    runtime.signal?.throwIfAborted();
     return { ...birth, adapter: selected };
 }
 async function runPreparedBody(input) {
-    let pendingTellDisposition;
-    try {
-        if (await recoverBodyRequests(input))
-            pendingTellDisposition = await runBodyTurns(input);
-    }
-    finally {
-        await input.supervisor.close();
-    }
-    return pendingTellDisposition;
+    return (await recoverBodyRequests(input)) ? await runBodyTurns(input) : undefined;
 }
 async function preserveBodyFailure(paths, leash, error, at) {
     if (!(await heartExists(paths)))
@@ -314,10 +196,25 @@ async function recoverBodyRequests(input) {
         if (!supervisor.signal.aborted)
             throw error;
         await clearBodyRequestTransport(launch.paths);
-        await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+        await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now, input.turnOutcome);
     }
     return false;
 }
+async function emitBodyBirth(launch, soul, world, bodySequence) {
+    await emitPluginSignal({
+        world,
+        reportDiagnostic: (message) => {
+            void recordPluginDiagnostic(launch.paths, "birth", message);
+        },
+    }, {
+        kind: "akuma.born",
+        akumaId: soul.id,
+        bodySequence,
+        ...projectAkumaBirth(soul),
+        ...(launch.birthInitiator === undefined ? {} : { initiator: launch.birthInitiator }),
+        ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
+    });
+}
 function turnStartedEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn started", message);
@@ -346,11 +243,12 @@ function turnOutcomeEmitter(launch, soul, world) {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
     };
     return {
-        async emit(turnSequence, outcome) {
+        async emit(turnSequence) {
             try {
                 const turn = await readTurn(launch.paths, turnSequence);
-                if (turn === null)
-                    throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
+                if (turn?.end === undefined)
+                    throw new Error(`Committed Turn ${turnSequence} outcome is missing from Heart`);
+                const outcome = turn.end.outcome;
                 const participants = await readTurnParticipants(launch.paths, turnSequence);
                 await emitPluginSignal({ world, reportDiagnostic }, {
                     kind: "akuma.turn-outcome",
@@ -359,9 +257,11 @@ function turnOutcomeEmitter(launch, soul, world) {
                     turnSequence,
                     ...(turn.initiator === undefined ? {} : { initiator: turn.initiator }),
                     ...(participants.length === 0 ? {} : { participants }),
-                    outcome: outcome.outcome === "answered"
+                    outcome: outcome.kind === "answered"
                         ? { kind: "answered", text: outcome.answer }
-                        : { kind: "failed", reason: outcome.diagnostic },
+                        : outcome.kind === "canceled"
+                            ? { kind: "canceled" }
+                            : { kind: "failed", reason: outcome.diagnostic },
                     ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
                 });
             }
@@ -405,7 +305,11 @@ async function admitInitialCallTell(runtime, input) {
         signal: input.signal,
         now: runtime.now,
         wake: async (tell) => await wakeRecordedTell(paths, tell.id, {
-            spawn: async (tellPaths) => await (runtime.spawnBody ?? spawnAkumaBody)({ paths: tellPaths, refuseIfHeld: true }),
+            spawn: async (tellPaths) => await runtime.requestSpawn({
+                paths: tellPaths,
+                refuseIfHeld: true,
+                ...(input.contractId === undefined ? {} : { completion: { contractId: input.contractId } }),
+            }),
             schedule: abortableDelay,
         }, input.signal),
     });
@@ -417,7 +321,7 @@ async function runBodyTurns(input) {
         const control = supervisor.current();
         const launchTells = drainPendingTells(control.pending, await readOpenBoundTurns(launch.paths, bodySequence), control.pause, bodySequence);
         if (supervisor.signal.aborted) {
-            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now, turnOutcome);
             return;
         }
         if (initial === undefined && launchTells.length === 0) {
@@ -426,6 +330,7 @@ async function runBodyTurns(input) {
                 return;
             if (finished.kind === "controlled") {
                 supervisor.cancel("control");
+                await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now, turnOutcome);
                 return;
             }
             continue;
@@ -437,7 +342,7 @@ async function runBodyTurns(input) {
             adapter,
             bodySequence,
             supervisor,
-            runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
+            runtimeSpawn: runtime.requestSpawn,
             admitInitialTell: async (admission) => await admitInitialCallTell(runtime, admission),
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
@@ -446,6 +351,7 @@ async function runBodyTurns(input) {
             ...(schema === undefined ? {} : { schemaJson: schema }),
             world: runtime.world,
             externalCommands: runtime.externalCommands,
+            ...(runtime.executionAssociation === undefined ? {} : { executionAssociation: runtime.executionAssociation }),
             now: runtime.now,
             turnStarted,
         });
@@ -454,18 +360,18 @@ async function runBodyTurns(input) {
             return;
         }
         if (result.kind === "stopped") {
-            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now, turnOutcome);
             return;
         }
         if (result.kind === "handoff")
-            return "handoff";
+            return await putDownBody(launch.paths, bodySequence, runtime.now, turnOutcome, true);
         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());
-        await turnOutcome.emit(result.turnSequence, outcome);
+        await turnOutcome.emit(result.turnSequence);
         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() });
@@ -493,56 +399,27 @@ async function settleUndeliveredDisposition(paths, disposition, error) {
 async function consumeProvenDisposition(paths, disposition) {
     return await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
 }
-/**
- * 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 consumeProvenDisposition(paths, disposition)) {
-            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 consumeProvenDisposition(paths, disposition)) {
-            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")
+        const child = await spawn({ paths, refuseIfHeld: true, handoffFromBodySequence: disposition.bodySequence });
+        const result = await observeBodyLaunch(child, async () => (await consumeProvenDisposition(paths, disposition)) ? true : null);
+        if (result.kind === "observed") {
+            child.release();
             return;
+        }
+        const wake = launchEndWake(result.end);
         // 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");
+        await settleUndeliveredDisposition(paths, disposition, wake.diagnostic);
     }
     catch (error) {
         await settleUndeliveredDisposition(paths, disposition, error);
     }
 }
-export async function handoffPendingTells(paths, spawn = spawnAkumaBody) {
+export async function handoffPendingTells(paths, spawn) {
     const open = await readOpenPendingTellDisposition(paths);
     if (open !== null) {
         await resolveDecidedPendingTellDisposition(paths, open, spawn);
@@ -565,29 +442,30 @@ export async function handoffPendingTells(paths, spawn = spawnAkumaBody) {
         return;
     await resolveDecidedPendingTellDisposition(paths, decided, spawn);
 }
-async function finishBody(paths, bodySequence, handoff, emitBodyEnd, now) {
+async function finishBody(paths, bodySequence, emitBodyEnd, now) {
     if (bodySequence === undefined || !(await heartExists(paths)))
-        return { decided: null };
+        return null;
     const body = (await readHeart(paths)).latestBody;
-    if (body?.sequence === bodySequence && (body.end !== undefined || body.hung !== undefined))
+    if (body?.sequence === bodySequence && (body.hung !== undefined || body.end === "broke-off"))
         await failOpenBoundTurns(paths, {
             bodySequence,
             diagnostic: body.hung?.diagnostic ?? `Body ${body.end ?? "ended"} with open bound Turns`,
             completedAt: now(),
         });
-    // A controlled put-down preserves pending Tells for a later ordinary wake.
-    // Only provider handoff creates this Body's frozen disposition snapshot.
-    const decided = handoff ? await decidePendingTellDisposition(paths, { bodySequence, at: now(), handoff }) : null;
     const finalBody = (await readHeart(paths)).latestBody;
-    let notification;
-    if (emitBodyEnd && finalBody?.sequence === bodySequence && (finalBody.end || finalBody.hung))
-        notification = emitBodyEnd(bodySequence, finalBody.hung === undefined ? finalBody.end : "hung", finalBody.hung?.diagnostic);
-    return { decided, ...(notification === undefined ? {} : { notification }) };
-}
-export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
+    if (finalBody?.sequence !== bodySequence)
+        return {};
+    const hung = finalBody.hung !== undefined;
+    const notification = emitBodyEnd && (finalBody.end || hung)
+        ? emitBodyEnd(bodySequence, hung ? "hung" : finalBody.end, finalBody.hung?.diagnostic)
+        : undefined;
+    return { ...(notification === undefined ? {} : { notification }), ...(hung ? { hung: true } : {}) };
+}
+export async function driveAkumaBody(launch, adapter, runtimeInput) {
+    runtimeInput.signal?.throwIfAborted();
     const world = runtimeInput.world ?? (await World.at(worldRootForAkumaPaths(launch.paths)));
-    const runtime = { ...DEFAULT_RUNTIME, ...runtimeInput, world };
-    const acquired = await takeLeash(launch.paths, launch.refuseIfHeld);
+    const runtime = { now: () => new Date().toISOString(), externalCommands: {}, ...runtimeInput, world };
+    const acquired = await takeLeash(launch.paths, launch.refuseIfHeld, runtime.signal);
     if (acquired === "held")
         return "held";
     if (acquired === "absent")
@@ -596,8 +474,9 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     let pendingTellDisposition = undefined;
     let bodySequence;
     let emitBodyEnd;
-    let emitTurnStarted;
     let emitTurnOutcome;
+    let supervisor;
+    let hung = false;
     try {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
         if (prepared === null) {
@@ -606,26 +485,19 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
             return;
         }
         emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
-        emitTurnStarted = turnStartedEmitter(launch, prepared.soul, world);
+        const emitTurnStarted = turnStartedEmitter(launch, prepared.soul, world);
         emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
-        const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
+        runtime.signal?.throwIfAborted();
+        const body = await leash.recordBody(launch.paths, {
+            leashTakenAt: runtime.now(),
+            ...(launch.handoffFromBodySequence === undefined
+                ? {}
+                : { handoffFromBodySequence: launch.handoffFromBodySequence }),
+        });
         bodySequence = body.sequence;
-        if (prepared.created) {
-            await emitPluginSignal({
-                world,
-                reportDiagnostic: (message) => {
-                    void recordPluginDiagnostic(launch.paths, "birth", message);
-                },
-            }, {
-                kind: "akuma.born",
-                akumaId: prepared.soul.id,
-                bodySequence: body.sequence,
-                ...projectAkumaBirth(prepared.soul),
-                ...(launch.birthInitiator === undefined ? {} : { initiator: launch.birthInitiator }),
-                ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-            });
-        }
-        const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);
+        supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash, runtime.signal, runtime.forceSignal);
+        if (prepared.created)
+            await emitBodyBirth(launch, prepared.soul, world, body.sequence);
         pendingTellDisposition = await runPreparedBody({
             launch,
             soul: prepared.soul,
@@ -640,45 +512,33 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     catch (error) {
         if (error instanceof BodyControlledError) {
             if (bodySequence !== undefined)
-                await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
+                await putDownBody(launch.paths, bodySequence, runtime.now, emitTurnOutcome);
             return "held";
         }
         await preserveBodyFailure(launch.paths, leash, error, runtime.now());
         throw error;
     }
     finally {
-        const finished = await finishBody(launch.paths, bodySequence, pendingTellDisposition === "handoff", emitBodyEnd, runtime.now);
-        leash.release();
-        if (finished.decided !== null)
-            await resolveDecidedPendingTellDisposition(launch.paths, finished.decided, runtime.spawnBody ?? spawnAkumaBody);
-        if (finished.notification !== undefined)
+        let finished;
+        try {
+            await supervisor?.close();
+            finished = await finishBody(launch.paths, bodySequence, emitBodyEnd, runtime.now);
+        }
+        finally {
+            leash.release();
+        }
+        if (finished !== null && pendingTellDisposition !== undefined)
+            await resolveDecidedPendingTellDisposition(launch.paths, pendingTellDisposition, runtime.spawn);
+        if (finished?.notification !== undefined)
             await finished.notification;
+        hung = finished?.hung === true;
     }
+    if (hung)
+        return "hung";
 }
-export async function spawnAkumaBody(launch) {
-    const input = await bodyProcessInput(launch, import.meta.url);
-    try {
-        return await spawnDetachedProcess(input);
-    }
-    catch (error) {
-        if (error?.code !== "ENOENT")
-            throw error;
-        throw await diagnoseSpawnEnoent(input, error);
-    }
-}
-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 }),
-    schedule: abortableDelay,
-};
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function preAdmissionDiagnostic(exit) {
-    return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
-}
 async function settledWake(paths, tellId, after) {
     const heart = await readHeart(paths);
     if (tellId !== undefined && !heart.pending.some((tell) => tell.id === tellId))
@@ -688,46 +548,14 @@ async function settledWake(paths, tellId, after) {
     }
     return null;
 }
-function failedChild(exit) {
-    return {
-        kind: "failed",
-        diagnostic: preAdmissionDiagnostic(exit),
-        child: { code: exit.code, signal: exit.signal, log: exit.log },
-    };
-}
 async function awaitWake(paths, input) {
     const { tellId, after, child, schedule, signal } = input;
     try {
-        for (;;) {
-            signal?.throwIfAborted();
-            const settled = await settledWake(paths, tellId, after);
-            if (settled !== null) {
-                child.release();
-                return settled;
-            }
-            const timerController = new AbortController();
-            const timer = schedule(WAKE_REREAD_MS, timerController.signal).then(() => ({ kind: "timer" }));
-            let winner;
-            try {
-                const waited = Promise.race([child.exited.then((exit) => ({ kind: "exited", exit })), timer]);
-                winner = signal === undefined ? await waited : await abortable(waited, signal);
-            }
-            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;
-            }
-            return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
-        }
+        const result = await observeBodyLaunch(child, async () => await settledWake(paths, tellId, after), schedule, signal);
+        if (result.kind === "completed")
+            return launchEndWake(result.end);
+        child.release();
+        return result.value;
     }
     catch (error) {
         child.release();
@@ -755,7 +583,7 @@ async function wakePendingTells(paths, tellId, runtime, signal) {
         return { kind: "failed", diagnostic: diagnostic(error) };
     }
 }
-export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE, signal) {
+export async function wakeRecordedTell(paths, tellId, runtime, signal) {
     const wake = (await wakePendingTells(paths, tellId, runtime, signal));
     const tell = await readTell(paths, tellId);
     if (tell === null)

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

@@ -1 +1,3 @@
+export declare function bareOption(value: unknown): boolean | undefined;
+export declare function writableDirectoriesOption(value: unknown): Promise<readonly string[]>;
 export declare function canonicalBirthCwd(input: string, diagnostic?: string): Promise<string>;