@astrosheep/keiyaku 4.0.0 → 4.0.2

package/build/src/akuma/body.js

@@ -1,18 +1,151 @@
 import { fileURLToPath } from "node:url";
-import { HeldAkumaLeash, advanceTell, appendActivity, breakBody, clearAbandonedControl, finishBodyIfIdle, heartExists, pauseRequested, readHeart, recordBody, recordSession, recordTurn, stopRequested, } from "./heart/index.js";
-import { encodeAgentEvent } from "./provider.js";
-import { providerNamed } from "./providers/index.js";
-import { BodyRequestPump, settleBodyRequests, } from "./requests.js";
-import { currentProcessCollar, probeProcessTree, putDownProcessTree, spawnDetachedProcess, } from "../runtime/proc/run.js";
+import { abortableDelay } from "./abort.js";
+import { HeldAkumaLeash, appendActivity, beginTurn, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { encodeAgentEvent, } from "./provider.js";
+import { resolveProviderExecution } from "./providers/index.js";
+import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./requests.js";
+import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+const BODY_CONTROL_OBSERVATION_MS = 100;
+export const CONTROL_RESPONSE_MS = 1_000;
+class BodySupervisor {
+    paths;
+    bodySequence;
+    leash;
+    signal;
+    controller = new AbortController();
+    finished = new AbortController();
+    observer;
+    waiter;
+    observation;
+    stopping;
+    constructor(paths, bodySequence, leash, observation) {
+        this.paths = paths;
+        this.bodySequence = bodySequence;
+        this.leash = leash;
+        this.signal = this.controller.signal;
+        this.observation = observation;
+        this.observer = this.observe();
+    }
+    static async open(paths, bodySequence, leash) {
+        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+    }
+    get reason() { return this.stopping; }
+    current() { return this.observation; }
+    async recordHung(diagnostic, at) {
+        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+    }
+    async refresh() {
+        this.publish(await readHeart(this.paths));
+        return this.observation;
+    }
+    next(after) {
+        if (this.observation !== after)
+            return Promise.resolve(this.observation);
+        return new Promise((resolve) => { this.waiter = resolve; });
+    }
+    cancel(reason) {
+        if (this.stopping !== undefined)
+            return;
+        this.stopping = reason;
+        this.controller.abort(new Error(reason === "control"
+            ? "Akuma Body interrupted by durable control"
+            : "Akuma Heart disappeared"));
+        this.waiter?.(this.observation);
+        this.waiter = undefined;
+    }
+    async close() {
+        this.finished.abort();
+        await this.observer;
+        this.waiter = undefined;
+    }
+    publish(snapshot) {
+        this.observation = snapshot;
+        this.waiter?.(snapshot);
+        this.waiter = undefined;
+    }
+    async observe() {
+        for (;;) {
+            const snapshot = this.observation;
+            if (!await heartExists(this.paths)) {
+                this.cancel("heart-gone");
+                return;
+            }
+            if (bodyControlRequested(snapshot, this.bodySequence)) {
+                this.cancel("control");
+                return;
+            }
+            try {
+                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
+            }
+            catch {
+                return;
+            }
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                if (await heartExists(this.paths))
+                    throw error;
+                this.cancel("heart-gone");
+                return;
+            }
+        }
+    }
+}
+function serializeEffects() {
+    let tail = Promise.resolve();
+    let failed = false;
+    let failure;
+    const serialize = async (effect) => {
+        const result = tail.then(effect);
+        tail = result.then(() => undefined, (error) => {
+            if (!failed)
+                failure = error;
+            failed = true;
+        });
+        return await result;
+    };
+    serialize.drain = async () => {
+        await tail;
+        if (failed)
+            throw failure;
+    };
+    return serialize;
 }
 function missing(error) {
-    return error.code === "ENOENT";
+    return isHeartAbsent(error) || error.code === "ENOENT";
 }
-function turnRecipe(paths, soul) {
-    const latest = readHeart(paths).latestSession;
+async function writeProviderEvent(input, active, event) {
+    if (input.supervisor.signal.aborted)
+        return;
+    const at = input.now();
+    if (event.type === "session") {
+        await recordSession(input.paths, {
+            provider: input.soul.provider.name,
+            coordinate: event.coordinate,
+            cwd: active.cwd,
+            options: active.options,
+            admittedAt: at,
+        });
+    }
+    await appendActivity(input.paths, {
+        turnSequence: active.turnSequence,
+        event: encodeAgentEvent(event),
+        at,
+    });
+}
+function bodyControlRequested(snapshot, bodySequence) {
+    return snapshot.stop?.bodySequence === bodySequence
+        || snapshot.pause?.bodySequence === bodySequence;
+}
+async function putDownIfControlled(paths, supervisor, bodySequence, now) {
+    if (supervisor.reason === "control" && await heartExists(paths)) {
+        await breakBody(paths, { sequence: bodySequence, end: "put-down", at: now() });
+    }
+}
+async function turnRecipe(paths, soul) {
+    const latest = (await readHeart(paths)).latestSession;
     const admitted = latest?.provider === soul.provider.name ? latest : undefined;
     const session = admitted?.coordinate;
     return {
@@ -24,7 +157,7 @@ function turnRecipe(paths, soul) {
 async function takeLeash(paths) {
     for (;;) {
         try {
-            const leash = HeldAkumaLeash.try(paths);
+            const leash = await HeldAkumaLeash.try(paths);
             if (leash !== null)
                 return leash;
         }
@@ -33,168 +166,305 @@ async function takeLeash(paths) {
                 return null;
             throw error;
         }
-        await wait(LEASH_RETRY_MS);
+        await abortableDelay(LEASH_RETRY_MS);
     }
 }
-async function settlePredecessor(paths) {
-    const predecessor = readHeart(paths).latestBody;
-    if (predecessor === null)
-        return true;
-    const probe = probeProcessTree(predecessor.collar);
-    if (probe.kind === "gone")
-        return true;
-    if (probe.kind === "unverifiable")
-        return false;
-    const evidence = await putDownProcessTree(predecessor.collar);
-    return evidence !== "unavailable" && evidence !== "alive-after-sigkill";
-}
 async function startTurnDrive(input) {
-    const { cwd, options, session } = turnRecipe(input.paths, input.soul);
+    const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
+    if (session !== undefined && input.adapter.resume === undefined)
+        return { kind: "resume-unsupported" };
+    const turn = await beginTurn(input.paths, {
+        bodySequence: input.bodySequence,
+        startedAt: input.now(),
+        ...(input.call === undefined ? {} : { call: input.call }),
+    });
     const requests = input.soul.confinement.kind === "declared"
-        ? new BodyRequestPump({
+        ? await BodyRequestPump.open({
             paths: input.paths,
             parent: input.soul,
             bodySequence: input.bodySequence,
             now: input.now,
             spawn: input.runtimeSpawn,
+            signal: input.supervisor.signal,
         })
         : null;
+    const driveInput = {
+        body: input.body,
+        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
+        cwd,
+        options,
+        signal: input.supervisor.signal,
+        ...(requests === null ? {} : { requests: { dir: requests.directory } }),
+    };
+    const setup = session === undefined
+        ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
+        : input.adapter.resume({ ...driveInput, session: { kind: "resume", coordinate: session } });
     try {
-        const drive = await input.adapter.start({
-            prompt: input.prompt,
-            cwd,
-            options,
-            ...(session === undefined ? {} : { session }),
-            ...(requests === null ? {} : { requests: { dir: requests.directory } }),
-        });
+        const selected = await setup;
+        if (input.supervisor.signal.aborted) {
+            await retireProviderCustody(input, turn.sequence, selected);
+            await requests?.close();
+            return { kind: "stopped" };
+        }
+        if (input.launchTells.length > 0) {
+            await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
+                tellId: tell.id,
+                route: "launch",
+                turnSequence: turn.sequence,
+                fence: selected.admission.fence,
+                deliveredAt: input.now(),
+            })));
+        }
         if (requests !== null)
-            void drive.completion.then(() => requests.stopAdmission());
-        return { drive, requests, cwd, options, ...(session === undefined ? {} : { session }) };
+            void selected.completion.then(() => requests.stopAdmission());
+        return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
+            ...(session === undefined ? {} : { resume: session }) };
     }
     catch (error) {
-        if (requests !== null)
-            await requests.close();
-        throw error;
+        await requests?.close();
+        if (input.supervisor.signal.aborted) {
+            if (input.supervisor.reason === "heart-gone")
+                throw error;
+            return { kind: "stopped" };
+        }
+        return {
+            kind: "failed",
+            turnSequence: turn.sequence,
+            diagnostic: error instanceof Error ? error.message : String(error),
+        };
     }
 }
+async function retireProviderCustody(input, turnSequence, drive) {
+    const outcome = await Promise.race([
+        drive.abort().then(() => ({ kind: "retired" }), (error) => ({ kind: "held", error })),
+        abortableDelay(CONTROL_RESPONSE_MS).then(() => ({
+            kind: "held",
+            error: new Error(`provider custody remained live after ${CONTROL_RESPONSE_MS}ms`),
+        })),
+    ]);
+    if (outcome.kind === "retired")
+        return;
+    if (await heartExists(input.paths)) {
+        const diagnostic = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+        const at = input.now();
+        try {
+            await input.supervisor.recordHung(diagnostic, at);
+            await appendActivity(input.paths, {
+                turnSequence,
+                event: encodeAgentEvent({ type: "note", text: `Provider custody was not retired: ${diagnostic}` }),
+                at,
+            });
+        }
+        catch { /* undisposed provider custody still owns the leash */ }
+    }
+    for (;;)
+        await abortableDelay(60_000);
+}
+function pumpReceipts(writers) {
+    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
+    return (async () => {
+        if (drive.receipts === undefined)
+            return;
+        for await (const receipt of drive.receipts) {
+            if (!mayWrite())
+                return;
+            await writeWitness(async () => {
+                if (!mayWrite())
+                    return;
+                await recordTellReceipt(input.paths, receipt.evidence === "exact"
+                    ? { ...receipt, receivedAt: input.now() }
+                    : { ...receipt, turnSequence, receivedAt: input.now() });
+            });
+        }
+    })();
+}
+function observeReceiptFailure(receiptPump) {
+    return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
+}
+async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
+    const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
+    for (const tell of pending) {
+        if (attempted.has(tell.id))
+            continue;
+        attempted.add(tell.id);
+        const outcome = await writeWitness(async () => {
+            const submission = await tellLive({ id: tell.id, text: tell.body });
+            if (!mayWrite())
+                return "turn-ended";
+            if (submission.kind === "turn-ended")
+                return "turn-ended";
+            await recordTellDeliveries(input.paths, [{
+                    tellId: tell.id,
+                    route: "live",
+                    turnSequence,
+                    fence: submission.fence,
+                    receipt: drive.receipts === undefined ? "unavailable" : "required",
+                    deliveredAt: input.now(),
+                }]);
+            return "accepted";
+        });
+        if (outcome === "turn-ended")
+            return "turn-ended";
+    }
+    return "live";
+}
+async function stopActiveDrive(input, active) {
+    await retireProviderCustody(input, active.turnSequence, active.drive);
+    await active.requests?.close();
+}
+function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
+    return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
+}
+function persistProviderEvent(_input, _active, event) {
+    return event.type === "session" ? event.coordinate : undefined;
+}
+async function settleCompletion(result, session, requests) {
+    await requests?.close();
+    return result.kind === "answered" ? { ...result, ...(session === undefined ? {} : { session }) } : result;
+}
 async function consumeTurnDrive(input, active) {
-    const { drive, requests, cwd, options, session } = active;
-    let turnSession = session;
-    let entered = false;
+    const { turnSequence, drive, requests, resume } = active;
+    let heart = input.supervisor.current();
+    let turnSession = resume;
+    const attempted = new Set(input.launchTells.map((tell) => tell.id));
+    const writeWitness = serializeEffects();
+    let writesOpen = true;
+    const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
+    const writers = { input, turnSequence, drive, writeWitness, mayWrite };
+    const receiptPump = pumpReceipts(writers);
+    const receiptFailure = observeReceiptFailure(receiptPump);
     const iterator = drive.events[Symbol.asyncIterator]();
     let pending = iterator.next();
-    for (;;) {
-        if (stopRequested(input.paths) || pauseRequested(input.paths)) {
-            const draining = requests?.close();
-            try {
-                await drive.abort();
+    let liveTells = true;
+    let tellPump = null;
+    let tellObservation = null;
+    try {
+        for (;;) {
+            if (input.supervisor.signal.aborted) {
+                writesOpen = false;
+                await stopActiveDrive(input, active);
+                return { kind: "stopped" };
             }
-            finally {
-                await draining;
+            if (hasUnattemptedTell(liveTells, tellPump, heart.pending, attempted)) {
+                if (drive.tell === undefined) {
+                    writesOpen = false;
+                    await stopActiveDrive(input, active);
+                    return { kind: "handoff" };
+                }
+                tellPump = submitPendingLiveTells(writers, heart.pending, attempted, drive.tell);
+                tellObservation = tellPump.then((result) => ({ kind: "tell", result }));
             }
-            return { kind: "stopped" };
+            const next = await Promise.race([
+                pending.then((event) => ({ kind: "event", event })),
+                input.supervisor.next(heart).then((observation) => ({ kind: "heart", observation })),
+                ...(tellObservation === null ? [] : [tellObservation]),
+                receiptFailure,
+                ...(requests === null ? [] : [requests.failure]),
+            ]);
+            if (next.kind === "event" && !next.event.done) {
+                await writeProviderEvent(input, active, next.event.value);
+            }
+            if (next.kind === "heart") {
+                heart = next.observation;
+                continue;
+            }
+            if (next.kind === "tell") {
+                tellPump = null;
+                tellObservation = null;
+                liveTells = next.result === "live";
+                continue;
+            }
+            if (next.event.done)
+                break;
+            turnSession = persistProviderEvent(input, active, next.event.value) ?? turnSession;
+            pending = iterator.next();
         }
-        const next = await Promise.race([
-            pending,
-            wait(LEASH_RETRY_MS).then(() => null),
-            ...(requests === null ? [] : [requests.failure]),
-        ]);
-        if (next === null)
-            continue;
-        if (next.done)
-            break;
-        const event = next.value;
-        const at = input.now();
-        if (event.type === "session") {
-            turnSession = event.coordinate;
-            recordSession(input.paths, {
-                provider: input.soul.provider.name,
-                coordinate: event.coordinate,
-                cwd,
-                options,
-                admittedAt: at,
-            });
+        const result = await drive.completion;
+        if (tellPump !== null)
+            await tellPump;
+        await writeWitness.drain();
+        writesOpen = false;
+        return await settleCompletion(result, turnSession, requests);
+    }
+    catch (error) {
+        writesOpen = false;
+        if (input.supervisor.signal.aborted) {
+            await stopActiveDrive(input, active);
+            return { kind: "stopped" };
         }
-        appendActivity(input.paths, {
-            bodySequence: input.bodySequence,
-            event: encodeAgentEvent(event),
-            at,
-        });
-        if (!entered && input.tellId !== undefined) {
-            entered = true;
-            advanceTell(input.paths, input.tellId, "seen");
-            advanceTell(input.paths, input.tellId, "consumed");
+        await retireProviderCustody(input, turnSequence, drive);
+        try {
+            await requests?.close();
         }
-        pending = iterator.next();
+        catch { /* preserve the first pump failure */ }
+        return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
     }
-    const result = await drive.completion;
-    if (requests !== null)
-        await requests.close();
-    if (!entered && result.kind === "answered" && input.tellId !== undefined) {
-        advanceTell(input.paths, input.tellId, "seen");
-        advanceTell(input.paths, input.tellId, "consumed");
-    }
-    return result.kind === "answered"
-        ? { ...result, ...(turnSession === undefined ? {} : { session: turnSession }) }
-        : result;
 }
 async function driveTurn(input) {
-    const active = await startTurnDrive(input);
+    let active;
     try {
-        return await consumeTurnDrive(input, active);
+        const started = await startTurnDrive(input);
+        if ("kind" in started)
+            return started;
+        active = started;
     }
     catch (error) {
-        const draining = active.requests?.close();
-        if (heartExists(input.paths)) {
-            await draining;
-            throw error;
-        }
-        try {
-            await active.drive.abort();
+        if (!await heartExists(input.paths)) {
+            input.supervisor.cancel("heart-gone");
+            return { kind: "stopped" };
         }
-        catch { /* the heart loss still owns shutdown */ }
-        try {
-            await draining;
+        throw error;
+    }
+    try {
+        const result = await consumeTurnDrive(input, active);
+        return result.kind === "stopped" || result.kind === "handoff"
+            ? result
+            : { ...result, turnSequence: active.turnSequence };
+    }
+    catch (error) {
+        if (await heartExists(input.paths)) {
+            await active.requests?.close();
+            return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error),
+                turnSequence: active.turnSequence };
         }
-        catch { /* the vanished heart owns the request loss */ }
-        return { kind: "heart-gone" };
+        input.supervisor.cancel("heart-gone");
+        await stopActiveDrive(input, active);
+        return { kind: "stopped" };
     }
 }
-function bornSoul(launch, leash, now) {
-    const before = readHeart(launch.paths);
-    if (before.death !== null)
-        return null;
-    if (before.soul !== null) {
-        clearAbandonedControl(launch.paths);
+async function bornSoul(launch, leash, now) {
+    const before = await readHeart(launch.paths);
+    if (before.soul !== null)
         return before.soul;
-    }
     if (launch.seed === undefined)
         throw new Error("Akuma wake has no born soul");
     const candidate = { ...launch.seed, createdAt: now };
-    if (leash.birth(launch.paths, candidate, launch.birthSession) === "sealed")
+    if (await leash.birth(launch.paths, candidate, launch.birthSession) === "sealed")
         return null;
-    const born = readHeart(launch.paths).soul;
+    const born = (await readHeart(launch.paths)).soul;
     if (born === null || born.id !== candidate.id) {
         throw new Error("Akuma birth identity does not match its directory");
     }
     return born;
 }
-function launchCwd(launch) {
+async function launchCwd(launch) {
     if (launch.seed !== undefined)
         return launch.seed.cwd;
-    const snapshot = readHeart(launch.paths);
-    const soul = snapshot.soul;
+    const soul = (await readHeart(launch.paths)).soul;
     if (soul === null)
         throw new Error("Akuma wake has no born soul");
-    return snapshot.latestSession?.provider === soul.provider.name
-        ? snapshot.latestSession.cwd
-        : soul.cwd;
+    return (await turnRecipe(launch.paths, soul)).cwd;
 }
-function persistTurn(paths, bodySequence, result, completedAt) {
-    recordTurn(paths, {
-        bodySequence,
+async function persistTurn(paths, turnSequence, result, completedAt) {
+    await endTurn(paths, {
+        turnSequence,
         outcome: result.kind === "answered" && result.session !== undefined
-            ? { kind: "answered", historyId: result.historyId, session: result.session, answer: result.answer }
+            ? {
+                kind: "answered",
+                session: result.session,
+                answer: result.answer,
+                ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
+            }
             : result.kind === "answered"
                 ? { kind: "failed", diagnostic: "Provider answered without a resumable session" }
                 : { kind: "failed", diagnostic: result.diagnostic },
@@ -204,82 +474,114 @@ function persistTurn(paths, bodySequence, result, completedAt) {
 }
 function defaultRuntime() {
     return {
-        collar: currentProcessCollar(),
         now: () => new Date().toISOString(),
-        putDownOwnTree: async (collar) => { await putDownProcessTree(collar); },
-        spawnChild: async (launch) => await spawnAkumaBody(launch),
+        spawnChild: spawnAkumaBody,
     };
 }
-function childSpawner(runtime) {
-    return runtime.spawnChild ?? spawnAkumaBody;
+async function prepareBodyStart(paths, leash) {
+    const before = await readHeart(paths);
+    if (before.pause !== null)
+        return false;
+    if (before.stop === null)
+        return true;
+    if (before.latestBody?.sequence === before.stop.bodySequence && before.latestBody.end === "put-down") {
+        await leash.settleStop(paths);
+    }
+    else {
+        await leash.clearStop(paths);
+    }
+    return true;
 }
-async function beginBody(paths, soul, runtime) {
-    if (!await settlePredecessor(paths))
-        return null;
-    const body = recordBody(paths, { collar: runtime.collar, leashTakenAt: runtime.now() });
-    if (await settleBodyRequests(paths, soul, runtime.now) === "settled")
-        return body;
-    breakBody(paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
-    return null;
+async function recoverBodyRequests(input) {
+    const { launch, soul, bodySequence, supervisor, runtime } = input;
+    try {
+        const result = await settleBodyRequests(launch.paths, soul, runtime.now, supervisor.signal);
+        await clearBodyRequestTransport(launch.paths);
+        if (result === "settled")
+            return true;
+        await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
+    }
+    catch (error) {
+        if (!supervisor.signal.aborted)
+            throw error;
+        await clearBodyRequestTransport(launch.paths);
+        await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+    }
+    return false;
+}
+async function runBodyTurns(input) {
+    const { launch, soul, adapter, bodySequence, supervisor, runtime } = input;
+    let initial = launch.initialBody;
+    for (;;) {
+        const launchTells = supervisor.current().pending;
+        if (supervisor.signal.aborted) {
+            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+            return;
+        }
+        if (initial === undefined && launchTells.length === 0) {
+            const finished = await finishBodyIfIdle(launch.paths, { sequence: bodySequence, at: runtime.now() });
+            if (finished.kind === "finished")
+                return;
+            if (finished.kind === "controlled") {
+                supervisor.cancel("control");
+                return;
+            }
+            continue;
+        }
+        const result = await driveTurn({
+            paths: launch.paths,
+            soul,
+            adapter,
+            bodySequence,
+            supervisor,
+            runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
+            body: initial ?? "",
+            ...(initial === undefined ? {} : { call: initial }),
+            launchTells,
+            now: runtime.now,
+        });
+        if (result.kind === "stopped") {
+            await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
+            return;
+        }
+        if (result.kind === "handoff") {
+            await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
+            return;
+        }
+        if (result.kind === "resume-unsupported"
+            || await persistTurn(launch.paths, result.turnSequence, result, runtime.now()) === "failed") {
+            await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
+            return;
+        }
+        await supervisor.refresh();
+        initial = undefined;
+    }
 }
 export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()) {
     const leash = await takeLeash(launch.paths);
     if (leash === null)
         return;
     try {
-        const soul = bornSoul(launch, leash, runtime.now());
+        const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
-        const selected = adapter ?? providerNamed(soul.provider);
-        const body = await beginBody(launch.paths, soul, runtime);
-        if (body === null)
+        const selected = adapter ?? resolveProviderExecution(soul.provider).adapter;
+        if (!await prepareBodyStart(launch.paths, leash))
             return;
-        let initial = launch.initialBody;
-        for (;;) {
-            const snapshot = readHeart(launch.paths);
-            if (snapshot.death !== null) {
-                breakBody(launch.paths, { sequence: body.sequence, end: "put-down", at: runtime.now() });
-                return;
-            }
-            const tell = initial === undefined ? snapshot.pending[0] : undefined;
-            const prompt = initial ?? tell?.body;
-            if (prompt === undefined) {
-                const finished = finishBodyIfIdle(launch.paths, { sequence: body.sequence, at: runtime.now() });
-                if (finished.kind === "finished")
-                    return;
-                continue;
-            }
-            if (tell !== undefined)
-                advanceTell(launch.paths, tell.id, "delivered");
-            const result = await driveTurn({
-                paths: launch.paths,
-                soul,
-                adapter: selected,
-                bodySequence: body.sequence,
-                runtimeSpawn: childSpawner(runtime),
-                prompt,
-                ...(tell === undefined ? {} : { tellId: tell.id }),
-                now: runtime.now,
-            });
-            if (result.kind === "heart-gone") {
-                await runtime.putDownOwnTree(runtime.collar);
-                return;
-            }
-            if (result.kind === "stopped") {
-                breakBody(launch.paths, { sequence: body.sequence, end: "put-down", at: runtime.now() });
-                return;
-            }
-            if (persistTurn(launch.paths, body.sequence, result, runtime.now()) === "failed") {
-                breakBody(launch.paths, { sequence: body.sequence, end: "broke-off", at: runtime.now() });
-                return;
-            }
-            initial = undefined;
+        const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
+        const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);
+        const execution = { launch, soul, adapter: selected, bodySequence: body.sequence, supervisor, runtime };
+        try {
+            if (await recoverBodyRequests(execution))
+                await runBodyTurns(execution);
+        }
+        finally {
+            await supervisor.close();
         }
     }
     catch (error) {
-        if (heartExists(launch.paths))
+        if (await heartExists(launch.paths))
             throw error;
-        await runtime.putDownOwnTree(runtime.collar);
     }
     finally {
         leash.release();
@@ -287,11 +589,16 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
 }
 export async function spawnAkumaBody(launch) {
     const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
-    return await spawnDetachedProcess({
+    const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
+    if (actorId === undefined)
+        throw new Error("Akuma wake has no born soul");
+    const owned = await spawnDetachedProcess({
         argv: [process.execPath, ...process.execArgv, fileURLToPath(import.meta.url), encoded],
-        cwd: launchCwd(launch),
+        cwd: await launchCwd(launch),
+        env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
         log: launch.paths.log,
     });
+    owned.release();
 }
 async function main() {
     const encoded = process.argv[2];