@astrosheep/keiyaku 4.1.2 → 4.1.3

package/build/src/akuma/akuma-handle.js

@@ -220,7 +220,7 @@ export class AkumaHandle {
                 archetype: source.archetype,
                 awaitAsleep: true,
                 launch: async (allocated) => {
-                    (await spawnAkumaBody({
+                    return await spawnAkumaBody({
                         paths: allocated.paths,
                         seed: {
                             id: allocated.id,
@@ -234,7 +234,7 @@ export class AkumaHandle {
                             origin: { kind: "fork", parent: this.id, at: input.at },
                         },
                         birthSession,
-                    })).release();
+                    });
                 },
             });
             return { kind: "forked", child: child.id };

package/build/src/akuma/akuma-product.js

@@ -92,7 +92,7 @@ export class Akuma {
         const published = await publishAkuma({
             worldPath: this.path,
             archetype: archetype.name,
-            launch: async (allocated) => (await spawnAkumaBody({
+            launch: async (allocated) => await spawnAkumaBody({
                 paths: allocated.paths,
                 seed: {
                     id: allocated.id,
@@ -102,7 +102,7 @@ export class Akuma {
                     origin: { kind: "direct" },
                 },
                 initialBody: input.body,
-            })).release(),
+            }),
         });
         return new AkumaHandle(published.id, this.path, {
             cwd,

package/build/src/akuma/body.js

@@ -84,8 +84,11 @@ export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url)
         throw new Error("Akuma wake has no born soul");
     const source = bodyModuleUrl.endsWith(".ts");
     const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
+    const argv = source
+        ? [process.execPath, "--import", import.meta.resolve("tsx"), entry, encoded]
+        : [process.execPath, entry, encoded];
     return {
-        argv: source ? [process.execPath, "--import", "tsx", entry, encoded] : [process.execPath, entry, encoded],
+        argv,
         cwd: await launchCwd(launch),
         env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
         log: launch.paths.log,

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

@@ -3,7 +3,7 @@ import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, S
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";

package/build/src/akuma/heart/index.js

@@ -3,7 +3,7 @@ import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingT
 import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;

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

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
+export declare function heartSchemaIsCurrent(database: DatabaseSync): boolean;
 export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 20)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 20);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)\n      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL CHECK (\n      action IN (\n        'akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill',\n        'contract.deliver', 'contract.review',\n        'task.add', 'task.addDocument', 'task.compose', 'task.update', 'task.start',\n        'task.stop', 'task.hold', 'task.resume', 'task.done', 'task.drop'\n      )\n    ),\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND action = 'akuma.call'\n        AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((action = 'akuma.call' AND child IS NOT NULL AND service_json IS NULL)\n          OR (action != 'akuma.call' AND child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
 export declare const LEASH_SCHEMA = "\n  PRAGMA journal_mode=DELETE;\n  CREATE TABLE IF NOT EXISTS leash_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 4)\n  ) STRICT;\n  INSERT OR IGNORE INTO leash_schema(singleton, version) VALUES (1, 4);\n  CREATE TABLE IF NOT EXISTS seal (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    evidence TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n";

package/build/src/akuma/heart/schema.js

@@ -11,6 +11,15 @@ export function assertHeartSchemaVersion(database) {
 export function assertLeashSchemaVersion(database) {
     assertSchemaVersion(database, "leash_schema", LEASH_SCHEMA_VERSION);
 }
+export function heartSchemaIsCurrent(database) {
+    try {
+        const row = database.prepare(`SELECT version FROM akuma_schema WHERE singleton = 1`).get();
+        return row?.version === HEART_SCHEMA_VERSION;
+    }
+    catch {
+        return false;
+    }
+}
 export const HEART_SCHEMA = `
   CREATE TABLE IF NOT EXISTS akuma_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),

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

@@ -8,6 +8,7 @@ export declare class HeartAbsentError extends Error {
     constructor(path: string, options?: ErrorOptions);
 }
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
+export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
 export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
 export declare function readTransaction<T>(database: DatabaseSync, body: () => T): T;

package/build/src/akuma/heart/storage.js

@@ -3,7 +3,7 @@ import { watch as watchDirectory } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { basename, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
-import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion } from "./schema.js";
+import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, } from "./schema.js";
 import { deletePauseControl, deleteStopControl, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
 import { insertTellFact } from "./tells.js";
 import { pruneActivityFacts } from "./timeline.js";
@@ -115,6 +115,23 @@ async function openHeart(path, verify = true) {
         throw error;
     }
 }
+export async function classifyHeartSchema(paths) {
+    let database;
+    try {
+        database = await openExistingDatabase(paths.heart);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return "unsupported";
+        throw error;
+    }
+    try {
+        return heartSchemaIsCurrent(database) ? "current" : "unsupported";
+    }
+    finally {
+        database.close();
+    }
+}
 export async function withHeart(paths, body) {
     const database = await openHeart(paths.heart);
     try {

package/build/src/akuma/nuke.js

@@ -2,7 +2,7 @@ import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
 import { CONTROL_RESPONSE_MS } from "./body.js";
-import { HeldAkumaLeash, readHeart, readKill, requestStop } from "./heart/index.js";
+import { HeldAkumaLeash, classifyHeartSchema, readHeart, readKill, requestStop } from "./heart/index.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
 const POLL_MS = 100;
 async function hasAkumaCustody(paths) {
@@ -201,8 +201,11 @@ async function nukeAkumaEntries(world) {
 export async function stopAkuma(world) {
     const entries = await nukeAkumaEntries(world);
     const held = [];
+    let prepared = false;
     try {
         for (const entry of entries) {
+            if ((await classifyHeartSchema(entry.paths)) === "unsupported")
+                continue;
             const snapshot = await readHeart(entry.paths);
             const leash = snapshot.soul !== null && snapshot.latestBody?.end === undefined
                 ? await stopRunningAkuma(entry)
@@ -222,6 +225,7 @@ export async function stopAkuma(world) {
                 throw error;
             }
         }
+        prepared = true;
         return async () => {
             try {
                 await nukeAliases(world);
@@ -236,7 +240,7 @@ export async function stopAkuma(world) {
         };
     }
     finally {
-        if (held.length !== entries.length) {
+        if (!prepared) {
             for (const leash of held.reverse())
                 leash.release();
         }

package/build/src/akuma/providers/claude/index.js

@@ -118,8 +118,91 @@ function finishClaudeInput(input, terminal) {
     else
         input.close();
 }
+async function consumeClaudeQuery(context) {
+    const { query, input, events, observation, progress, admit, rejectAdmission, settle, controls } = context;
+    let admitted = false;
+    let terminal = null;
+    let historyId;
+    try {
+        for await (const message of query) {
+            if (!admitted && "session_id" in message && typeof message.session_id === "string") {
+                admitted = true;
+                events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
+                admit();
+            }
+            emitClaudeMessage(message, events, observation);
+            if (message.type === "assistant" &&
+                message.parent_tool_use_id === null &&
+                typeof message.uuid === "string" &&
+                message.uuid.length > 0)
+                historyId = message.uuid;
+            if (message.type !== "result")
+                continue;
+            if (message.subtype === "success") {
+                terminal = successfulResult(message, historyId);
+                progress.checkpoint += 1;
+                controls.flushReceipts();
+                queueMicrotask(controls.closeWhenIdle);
+            }
+            else {
+                terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
+                input.close();
+            }
+        }
+        progress.ended = true;
+        const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
+        if (!admitted)
+            rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
+        settle(result);
+    }
+    catch (error) {
+        progress.ended = true;
+        input.fail(error);
+        const failure = error instanceof Error ? error : new Error(String(error));
+        if (!admitted)
+            rejectAdmission(failure);
+        settle({ kind: "failed", diagnostic: failure.message });
+    }
+    finally {
+        finishClaudeInput(input, terminal);
+        events.end();
+        controls.settleReceipts();
+    }
+}
+function claudeTell(input, observed, accepted, state, run) {
+    return (tell) => {
+        if (observed.ended || input.closed)
+            return Promise.resolve({ kind: "turn-ended" });
+        state.openSubmissions += 1;
+        const ordinal = ++state.submission;
+        return new Promise((resolve, reject) => {
+            const pending = { id: tell.id, afterCheckpoint: 0, visible: false };
+            void input
+                .push(claudeUserMessage(tell.text), () => {
+                pending.afterCheckpoint = observed.checkpoint;
+                accepted.push(pending);
+            })
+                .then(() => {
+                state.openSubmissions -= 1;
+                resolve({ kind: "accepted", fence: `claude:${run}:${ordinal}` });
+                queueMicrotask(() => {
+                    pending.visible = true;
+                    observed.flushReceipts();
+                    observed.settleReceipts();
+                });
+            }, (error) => {
+                state.openSubmissions -= 1;
+                if (isClaudeTurnEnded(error))
+                    resolve({ kind: "turn-ended" });
+                else
+                    reject(error);
+                observed.settleReceipts();
+            });
+        });
+    };
+}
 function observeClaudeQuery(context) {
-    const { query, input, events, receipts, accepted, state } = context;
+    const { input, receipts, accepted, state } = context;
     const observation = { tools: new Map() };
     let admit;
     let rejectAdmission;
@@ -131,15 +214,15 @@ function observeClaudeQuery(context) {
     const completion = new Promise((resolve) => {
         settle = resolve;
     });
-    let checkpoint = 0, ended = false;
+    const progress = { checkpoint: 0, ended: false };
     const settleReceipts = () => {
-        if (ended && state.openSubmissions === 0 && accepted.every((tell) => tell.visible))
+        if (progress.ended && state.openSubmissions === 0 && accepted.every((tell) => tell.visible))
             receipts.end();
     };
     const flushReceipts = () => {
         for (let index = 0; index < accepted.length;) {
             const tell = accepted[index];
-            if (!tell.visible || tell.afterCheckpoint >= checkpoint) {
+            if (!tell.visible || tell.afterCheckpoint >= progress.checkpoint) {
                 index += 1;
                 continue;
             }
@@ -153,64 +236,23 @@ function observeClaudeQuery(context) {
         if (state.openSubmissions === 0 && accepted.length === 0 && input.pending === 0)
             input.close();
     };
-    void (async () => {
-        let admitted = false;
-        let terminal = null;
-        let historyId;
-        try {
-            for await (const message of query) {
-                if (!admitted && "session_id" in message && typeof message.session_id === "string") {
-                    admitted = true;
-                    events.emit({ type: "session", coordinate: { sessionId: message.session_id } });
-                    admit();
-                }
-                emitClaudeMessage(message, events, observation);
-                if (message.type === "assistant" &&
-                    message.parent_tool_use_id === null &&
-                    typeof message.uuid === "string" &&
-                    message.uuid.length > 0)
-                    historyId = message.uuid;
-                if (message.type !== "result")
-                    continue;
-                if (message.subtype === "success") {
-                    terminal = successfulResult(message, historyId);
-                    checkpoint += 1;
-                    flushReceipts();
-                    queueMicrotask(closeWhenIdle);
-                }
-                else {
-                    terminal = { kind: "failed", diagnostic: message.errors.join("; ") || message.subtype };
-                    input.close();
-                }
-            }
-            ended = true;
-            const result = terminal ?? { kind: "failed", diagnostic: "Claude query ended without a result" };
-            if (!admitted)
-                rejectAdmission(new Error(result.kind === "failed" ? result.diagnostic : "Claude query ended before session admission"));
-            settle(result);
-        }
-        catch (error) {
-            ended = true;
-            input.fail(error);
-            const failure = error instanceof Error ? error : new Error(String(error));
-            if (!admitted)
-                rejectAdmission(failure);
-            settle({ kind: "failed", diagnostic: failure.message });
-        }
-        finally {
-            finishClaudeInput(input, terminal);
-            events.end();
-            settleReceipts();
-        }
-    })();
+    void consumeClaudeQuery({
+        ...context,
+        observation,
+        progress,
+        admit,
+        rejectAdmission,
+        settle,
+        controls: { flushReceipts, settleReceipts, closeWhenIdle },
+    });
     return {
         admission,
         completion,
         get ended() {
-            return ended;
+            return progress.ended;
         },
         get checkpoint() {
-            return checkpoint;
+            return progress.checkpoint;
         },
         flushReceipts,
         settleReceipts,
@@ -229,8 +271,7 @@ async function driveClaude(load, execution, drive) {
     const abortController = new AbortController();
     const run = randomUUID();
     const accepted = [];
-    let submission = 0;
-    let openSubmissions = 0;
+    const driveState = { submission: 0, openSubmissions: 0 };
     const launchAcknowledged = input.push(claudeUserMessage(launchText(drive)));
     const query = sdk.query({
         prompt: input.iterable,
@@ -251,7 +292,7 @@ async function driveClaude(load, execution, drive) {
         accepted,
         state: {
             get openSubmissions() {
-                return openSubmissions;
+                return driveState.openSubmissions;
             },
         },
     });
@@ -266,36 +307,7 @@ async function driveClaude(load, execution, drive) {
         events,
         receipts,
         completion: observed.completion,
-        tell(tell) {
-            if (observed.ended || input.closed)
-                return Promise.resolve({ kind: "turn-ended" });
-            openSubmissions += 1;
-            const ordinal = ++submission;
-            return new Promise((resolve, reject) => {
-                const pending = { id: tell.id, afterCheckpoint: 0, visible: false };
-                void input
-                    .push(claudeUserMessage(tell.text), () => {
-                    pending.afterCheckpoint = observed.checkpoint;
-                    accepted.push(pending);
-                })
-                    .then(() => {
-                    openSubmissions -= 1;
-                    resolve({ kind: "accepted", fence: `claude:${run}:${ordinal}` });
-                    queueMicrotask(() => {
-                        pending.visible = true;
-                        observed.flushReceipts();
-                        observed.settleReceipts();
-                    });
-                }, (error) => {
-                    openSubmissions -= 1;
-                    if (isClaudeTurnEnded(error))
-                        resolve({ kind: "turn-ended" });
-                    else
-                        reject(error);
-                    observed.settleReceipts();
-                });
-            });
-        },
+        tell: claudeTell(input, observed, accepted, driveState, run),
         async abort() {
             shutDown(new Error("Claude query aborted"));
             await observed.completion;

package/build/src/akuma/providers/codex-app-server/index.js

@@ -124,12 +124,8 @@ async function abortTurn(server, state, settle) {
         settle({ kind: "failed", diagnostic: "codex app-server interrupted" });
     await server.close(true);
 }
-async function startCodex(execution, input) {
-    const signal = input.signal ?? new AbortController().signal;
-    if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
-        throw new Error("Codex app-server resume requires sessionId");
-    const events = new AgentEventChannel();
-    const server = new LineRpcProcess({
+function codexServer(execution, input) {
+    return new LineRpcProcess({
         argv: [execution.executable ?? "codex", "app-server", "--listen", "stdio://"],
         cwd: input.cwd,
         ...(execution.env === undefined && input.requests === undefined
@@ -142,6 +138,13 @@ async function startCodex(execution, input) {
                 },
             }),
     });
+}
+async function startCodex(execution, input) {
+    const signal = input.signal ?? new AbortController().signal;
+    if (input.session.kind === "resume" && !("sessionId" in input.session.coordinate))
+        throw new Error("Codex app-server resume requires sessionId");
+    const events = new AgentEventChannel();
+    const server = codexServer(execution, input);
     const state = { settled: false, tools: new Map() };
     let settle;
     const completion = new Promise((resolve) => {

package/build/src/akuma/providers/opencode-sdk/index.js

@@ -201,6 +201,26 @@ async function forceDisposeOpencode(abortController, close, finish) {
     await close();
     await finish({ kind: "failed", diagnostic: "OpenCode session force-disposed" });
 }
+async function loadDriveRuntime(execution, input, signal, loader) {
+    return await abortable(loadOpencode({
+        ...execution,
+        env: {
+            ...execution.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
+    }, input.cwd, signal, loader), signal, async (late) => await late.close());
+}
+async function openDriveSession(runtime, input, resumeSessionId, signal) {
+    const session = runtime.client.session;
+    const response = await abortable(input.session.kind === "fresh"
+        ? session.create({ query: { directory: input.cwd }, throwOnError: true })
+        : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), signal);
+    const info = object(object(response)?.data) ?? object(response);
+    const sessionId = text(info?.id) ?? resumeSessionId;
+    if (sessionId === undefined)
+        throw new Error("OpenCode did not return a session id");
+    return { session, sessionId };
+}
 async function drive(execution, input, loader) {
     admit(input.options);
     const signal = input.signal ?? new AbortController().signal;
@@ -209,13 +229,7 @@ async function drive(execution, input, loader) {
     const abortSetup = () => abortController.abort(signal.reason);
     signal.addEventListener("abort", abortSetup, { once: true });
     signal.throwIfAborted();
-    const runtime = await abortable(loadOpencode({
-        ...execution,
-        env: {
-            ...execution.env,
-            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
-        },
-    }, input.cwd, abortController.signal, loader), abortController.signal, async (late) => await late.close());
+    const runtime = await loadDriveRuntime(execution, input, abortController.signal, loader);
     let closing;
     let iterator;
     const closeOnce = () => {
@@ -223,14 +237,7 @@ async function drive(execution, input, loader) {
         return closing;
     };
     try {
-        const session = runtime.client.session;
-        const sessionResponse = await abortable(input.session.kind === "fresh"
-            ? session.create({ query: { directory: input.cwd }, throwOnError: true })
-            : session.get({ path: { id: resumeSessionId }, query: { directory: input.cwd }, throwOnError: true }), abortController.signal);
-        const info = object(object(sessionResponse)?.data) ?? object(sessionResponse);
-        const sessionId = text(info?.id) ?? resumeSessionId;
-        if (sessionId === undefined)
-            throw new Error("OpenCode did not return a session id");
+        const { session, sessionId } = await openDriveSession(runtime, input, resumeSessionId, abortController.signal);
         const events = new AgentEventChannel();
         const state = createEventState(sessionId);
         const messageID = `msg_${randomUUID().replaceAll("-", "")}`;

package/build/src/akuma/providers/pi/index.js

@@ -83,6 +83,32 @@ function forceDisposePi(dispose, settle, setAborting) {
     settle({ kind: "failed", diagnostic: "Pi session force-disposed" });
     return Promise.resolve();
 }
+async function runPiPrompt(native, input, events, state, settle) {
+    try {
+        await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
+        let result;
+        if (state.aborting)
+            result = { kind: "failed", diagnostic: "Pi session aborted" };
+        else if (state.terminalFailure !== null)
+            result = { kind: "failed", diagnostic: state.terminalFailure };
+        else if (!events.assistantSeen)
+            result = { kind: "failed", diagnostic: "Pi completed without a native assistant answer" };
+        else {
+            const historyId = native.sessionManager.getLeafId();
+            result = {
+                kind: "answered",
+                answer: events.answer,
+                ...(historyId === null ? {} : { historyId }),
+            };
+        }
+        settle(result);
+    }
+    catch (error) {
+        settle(state.aborting
+            ? { kind: "failed", diagnostic: "Pi session aborted" }
+            : { kind: "failed", diagnostic: diagnostic(error) });
+    }
+}
 async function drivePi(sdk, execution, input, signal) {
     const created = await createPiSession(sdk, execution, input, signal);
     const native = created.session;
@@ -95,16 +121,17 @@ async function drivePi(sdk, execution, input, signal) {
         throw new Error("Pi session admitted without sessionFile");
     }
     const events = new AgentEventChannel();
-    const state = { answer: "", assistantSeen: false, tools: new Map() };
-    let terminalFailure = null;
-    let disposed = false;
-    let abortRequest;
-    let aborting = false;
-    let settled = false;
+    const eventState = { answer: "", assistantSeen: false, tools: new Map() };
+    const state = {
+        terminalFailure: null,
+        disposed: false,
+        aborting: false,
+        settled: false,
+    };
     const dispose = () => {
-        if (disposed)
+        if (state.disposed)
             return;
-        disposed = true;
+        state.disposed = true;
         try {
             unsubscribe();
         }
@@ -119,8 +146,8 @@ async function drivePi(sdk, execution, input, signal) {
     };
     const unsubscribe = native.subscribe((event) => {
         if (event.type === "agent_end" && !event.willRetry)
-            terminalFailure = piTerminalFailure(event.messages);
-        for (const translated of translatePiEvent(event, state))
+            state.terminalFailure = piTerminalFailure(event.messages);
+        for (const translated of translatePiEvent(event, eventState))
             events.emit(translated);
     });
     events.emit({ type: "session", coordinate: { sessionFile: native.sessionFile, sessionId: native.sessionId } });
@@ -129,47 +156,22 @@ async function drivePi(sdk, execution, input, signal) {
         settleCompletion = resolve;
     });
     const settle = (result) => {
-        if (settled)
+        if (state.settled)
             return;
-        settled = true;
+        state.settled = true;
         dispose();
         settleCompletion(result);
     };
-    void (async () => {
-        try {
-            await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
-            let result;
-            if (aborting)
-                result = { kind: "failed", diagnostic: "Pi session aborted" };
-            else if (terminalFailure !== null)
-                result = { kind: "failed", diagnostic: terminalFailure };
-            else if (!state.assistantSeen)
-                result = { kind: "failed", diagnostic: "Pi completed without a native assistant answer" };
-            else {
-                const historyId = native.sessionManager.getLeafId();
-                result = {
-                    kind: "answered",
-                    answer: state.answer,
-                    ...(historyId === null ? {} : { historyId }),
-                };
-            }
-            settle(result);
-        }
-        catch (error) {
-            settle(aborting
-                ? { kind: "failed", diagnostic: "Pi session aborted" }
-                : { kind: "failed", diagnostic: diagnostic(error) });
-        }
-    })();
+    void runPiPrompt(native, input, eventState, state, settle);
     return {
         admission: { fence: native.sessionId },
         events,
         completion,
         abort: () => {
-            abortRequest ??= (async () => {
-                if (settled)
+            state.abortRequest ??= (async () => {
+                if (state.settled)
                     return;
-                aborting = true;
+                state.aborting = true;
                 try {
                     await native.abort();
                 }
@@ -178,10 +180,10 @@ async function drivePi(sdk, execution, input, signal) {
                 }
                 settle({ kind: "failed", diagnostic: "Pi session aborted" });
             })();
-            return abortRequest;
+            return state.abortRequest;
         },
         forceDispose: () => forceDisposePi(dispose, settle, () => {
-            aborting = true;
+            state.aborting = true;
         }),
     };
 }

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

@@ -1,10 +1,11 @@
 import { type AllocatedAkuma } from "./identity.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare const BIRTH_TIMEOUT_MS = 30000;
 export declare function publishAkuma(input: Readonly<{
     worldPath: string;
     archetype: string;
     awaitAsleep?: boolean;
     reserve?(allocated: AllocatedAkuma): Promise<void>;
-    launch(allocated: AllocatedAkuma): Promise<void>;
+    launch(allocated: AllocatedAkuma): Promise<OwnedProcess | void>;
     signal?: AbortSignal;
 }>): Promise<AllocatedAkuma>;

package/build/src/akuma/publication.js

@@ -40,7 +40,40 @@ async function observedBirthFailure(paths) {
         leash.release();
     }
 }
-async function awaitBirth(paths, signal) {
+function preAdmissionDiagnostic(exit) {
+    return exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`;
+}
+async function sealObservedExit(paths, exit) {
+    const evidence = preAdmissionDiagnostic(exit);
+    try {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null) {
+            try {
+                await leash.sealIfUnborn(paths, { evidence, at: new Date().toISOString() });
+            }
+            finally {
+                leash.release();
+            }
+        }
+    }
+    catch {
+        /* Parent evidence remains authoritative when best-effort sealing fails. */
+    }
+    throw new Error(evidence);
+}
+async function observeSettledExit(owned) {
+    if (owned === undefined)
+        return { kind: "pending" };
+    const pending = Symbol("pending");
+    try {
+        const exit = await Promise.race([owned.exited, Promise.resolve(pending)]);
+        return exit === pending ? { kind: "pending" } : { kind: "exited", exit };
+    }
+    catch (error) {
+        return { kind: "exit-error", error };
+    }
+}
+async function awaitBirth(paths, owned, signal) {
     const deadline = performance.now() + BIRTH_TIMEOUT_MS;
     for (;;) {
         signal?.throwIfAborted();
@@ -48,14 +81,37 @@ async function awaitBirth(paths, signal) {
         if (soul !== null)
             return soul;
         const failure = await observedBirthFailure(paths);
-        if (failure !== null)
+        if (failure !== null) {
+            const settled = await observeSettledExit(owned);
+            if (settled.kind === "exited")
+                await sealObservedExit(paths, settled.exit);
+            if (settled.kind === "exit-error")
+                throw new Error(diagnostic(settled.error));
             throw new Error(failure);
+        }
         if (performance.now() >= deadline) {
             const settled = await settleTimedOutBirth(paths);
             if (settled !== null)
                 return settled;
         }
-        await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+        if (owned === undefined) {
+            await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal);
+            continue;
+        }
+        const outcome = await Promise.race([
+            abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())), signal).then(() => "poll"),
+            owned.exited.then((exit) => ({ kind: "exited", exit }), (error) => ({ kind: "exit-error", error })),
+        ]);
+        if (outcome === "poll")
+            continue;
+        if (outcome.kind === "exited") {
+            const settledSoul = await readSoul(paths);
+            if (settledSoul !== null)
+                return settledSoul;
+            await sealObservedExit(paths, outcome.exit);
+            continue;
+        }
+        throw new Error(diagnostic(outcome.error));
     }
 }
 async function takeLeashUntil(paths, deadline) {
@@ -108,17 +164,22 @@ export async function publishAkuma(input) {
         input.signal?.throwIfAborted();
         await input.reserve?.(allocated);
         input.signal?.throwIfAborted();
-        await input.launch(allocated);
-        input.signal?.throwIfAborted();
+        const owned = await input.launch(allocated);
+        try {
+            input.signal?.throwIfAborted();
+            const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
+            if (soul.id !== allocated.id)
+                throw new Error("Akuma birth returned a different identity");
+            if (input.awaitAsleep === true)
+                await awaitAsleepBirth(allocated.paths);
+            return allocated;
+        }
+        finally {
+            owned?.release();
+        }
     }
     catch (error) {
         await sealLocalFailure(allocated, error);
         throw error;
     }
-    const soul = await awaitBirth(allocated.paths, input.signal);
-    if (soul.id !== allocated.id)
-        throw new Error("Akuma birth returned a different identity");
-    if (input.awaitAsleep === true)
-        await awaitAsleepBirth(allocated.paths);
-    return allocated;
 }

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

@@ -1,6 +1,8 @@
 import type { UpstreamRequestService } from "./heart/index.js";
 import type { ServeInput, UpstreamFact } from "./request-serve.js";
-export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<Readonly<{
+type ExecutionResult = Readonly<{
     result: unknown;
     service?: UpstreamRequestService;
-}>>;
+}>;
+export declare function executeRequest(input: ServeInput, request: UpstreamFact): Promise<ExecutionResult>;
+export {};

package/build/src/akuma/request-execution.js

@@ -1,78 +1,90 @@
+async function executeWait(input, request) {
+    return {
+        result: await input.upstream.wait({
+            targets: request.targets,
+            completion: request.completion,
+            ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+            signal: input.signal,
+        }),
+        service: { action: request.action },
+    };
+}
+async function executeTell(input, request) {
+    return {
+        result: await input.upstream.tell({
+            target: request.target,
+            body: request.body,
+            tellId: request.id,
+            recordedAt: request.admittedAt,
+            signal: input.signal,
+        }),
+        service: { action: request.action, target: request.target, tellId: request.id },
+    };
+}
+async function executeKill(input, request) {
+    const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
+    return { result: served.result, service: { action: request.action, results: served.service } };
+}
+async function executeDeliver(input, request) {
+    const served = await input.upstream.deliver({
+        repoRoot: request.repoRoot,
+        contractId: request.contractId,
+        ...(request.message === undefined ? {} : { message: request.message }),
+        includeDirty: request.includeDirty,
+        materializeConflict: request.materializeConflict,
+        requester: request.requester,
+        signal: input.signal,
+    });
+    return {
+        result: served.result,
+        ...(served.deliveryFactId === undefined
+            ? {}
+            : {
+                service: {
+                    action: request.action,
+                    repoRoot: request.repoRoot,
+                    contractId: request.contractId,
+                    deliveryFactId: served.deliveryFactId,
+                },
+            }),
+    };
+}
+async function executeReview(input, request) {
+    const served = await input.upstream.review({
+        repoRoot: request.repoRoot,
+        contractId: request.contractId,
+        verdict: request.verdict,
+        ...(request.summary === undefined ? {} : { summary: request.summary }),
+        requester: request.requester,
+        signal: input.signal,
+    });
+    return {
+        result: served.result,
+        ...(served.reviewFactId === undefined
+            ? {}
+            : {
+                service: {
+                    action: request.action,
+                    repoRoot: request.repoRoot,
+                    contractId: request.contractId,
+                    reviewFactId: served.reviewFactId,
+                },
+            }),
+    };
+}
 export async function executeRequest(input, request) {
     if (input.upstream === undefined)
         throw new Error("upstream execution port is unavailable");
     if (request.action === "akuma.wait")
-        return {
-            result: await input.upstream.wait({
-                targets: request.targets,
-                completion: request.completion,
-                ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
-                signal: input.signal,
-            }),
-            service: { action: request.action },
-        };
+        return executeWait(input, request);
     if (request.action === "akuma.tell")
-        return {
-            result: await input.upstream.tell({
-                target: request.target,
-                body: request.body,
-                tellId: request.id,
-                recordedAt: request.admittedAt,
-                signal: input.signal,
-            }),
-            service: { action: request.action, target: request.target, tellId: request.id },
-        };
-    if (request.action === "akuma.kill") {
-        const served = await input.upstream.kill({ targets: request.targets, signal: input.signal });
-        return { result: served.result, service: { action: request.action, results: served.service } };
-    }
-    if (request.action === "contract.deliver") {
-        const served = await input.upstream.deliver({
-            repoRoot: request.repoRoot,
-            contractId: request.contractId,
-            ...(request.message === undefined ? {} : { message: request.message }),
-            includeDirty: request.includeDirty,
-            materializeConflict: request.materializeConflict,
-            requester: request.requester,
-            signal: input.signal,
-        });
-        return {
-            result: served.result,
-            ...(served.deliveryFactId === undefined
-                ? {}
-                : {
-                    service: {
-                        action: request.action,
-                        repoRoot: request.repoRoot,
-                        contractId: request.contractId,
-                        deliveryFactId: served.deliveryFactId,
-                    },
-                }),
-        };
-    }
-    if (request.action === "contract.review") {
-        const served = await input.upstream.review({
-            repoRoot: request.repoRoot,
-            contractId: request.contractId,
-            verdict: request.verdict,
-            ...(request.summary === undefined ? {} : { summary: request.summary }),
-            requester: request.requester,
-            signal: input.signal,
-        });
-        return {
-            result: served.result,
-            ...(served.reviewFactId === undefined
-                ? {}
-                : {
-                    service: {
-                        action: request.action,
-                        repoRoot: request.repoRoot,
-                        contractId: request.contractId,
-                        reviewFactId: served.reviewFactId,
-                    },
-                }),
-        };
-    }
+        return executeTell(input, request);
+    if (request.action === "akuma.kill")
+        return executeKill(input, request);
+    if (request.action === "contract.deliver")
+        return executeDeliver(input, request);
+    if (request.action === "contract.review")
+        return executeReview(input, request);
     const task = request;
     return {
         result: await input.upstream.task({

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

@@ -2,6 +2,7 @@ import { type KillEvidence, type RequestFact, type Soul } from "./heart/index.js
 import { type AkuId, type AkumaPaths } from "./identity.js";
 import { type StructuralRequestClaim } from "./request-wire.js";
 import { type TaskMutationRequest } from "../task/mutation.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
 export type RequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
@@ -64,7 +65,7 @@ type PumpInput = Readonly<{
     parent: Soul;
     bodySequence: number;
     now(): string;
-    spawn(launch: RequestChildLaunch): Promise<void>;
+    spawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
     upstream?: UpstreamExecutionPort;
     signal: AbortSignal;
 }>;

package/build/src/akuma/request-serve.js

@@ -119,7 +119,7 @@ async function serveCall(input) {
             launch: async (allocated) => {
                 if (!input.admissionOpen())
                     throw new Error("body closed request admission");
-                await input.spawn({
+                return await input.spawn({
                     paths: allocated.paths,
                     seed: {
                         id: allocated.id,

package/build/src/akuma/turn-drive.d.ts

@@ -3,6 +3,7 @@ import type { AkumaPaths } from "./identity.js";
 import { type ProviderAdapter, type TurnResult } from "./provider.js";
 import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.js";
 import { BodySupervisor } from "./body-supervisor.js";
+import type { OwnedProcess } from "../runtime/proc/run.js";
 export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
     cwd: string;
     options: Soul["options"];
@@ -24,7 +25,7 @@ export type DriveTurnInput = Readonly<{
     call?: string;
     launchTells: readonly TellFact[];
     supervisor: BodySupervisor;
-    runtimeSpawn(launch: RequestChildLaunch): Promise<void>;
+    runtimeSpawn(launch: RequestChildLaunch): Promise<OwnedProcess | void>;
     upstream?: UpstreamExecutionPort;
     now(): string;
 }>;

package/build/src/akuma/turn-drive.js

@@ -126,7 +126,7 @@ async function startTurnDrive(input) {
                 fence: selected.admission.fence,
                 deliveredAt: input.now(),
             })));
-        void selected.completion.then(() => requests.stopAdmission());
+        void selected.completion.then(() => requests.stopAdmission(), () => undefined);
         return {
             turnSequence: turn.sequence,
             drive: selected,
@@ -194,6 +194,9 @@ function pumpReceipts(writers) {
 function observeReceiptFailure(receiptPump) {
     return receiptPump.then(() => new Promise(() => { }), (error) => Promise.reject(error));
 }
+function observeCompletionFailure(drive) {
+    return drive.completion.then(() => new Promise(() => { }), (error) => ({ kind: "completion-failed", error }));
+}
 async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
     const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
     for (const tell of pending) {
@@ -253,6 +256,7 @@ async function consumeTurnDrive(input, active) {
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;
     const writers = { input, turnSequence, drive, writeWitness, mayWrite };
     const receiptFailure = observeReceiptFailure(pumpReceipts(writers));
+    const completionFailure = observeCompletionFailure(drive);
     const iterator = drive.events[Symbol.asyncIterator]();
     let pending = iterator.next();
     let liveTells = true;
@@ -280,7 +284,12 @@ async function consumeTurnDrive(input, active) {
                 ...(tellObservation === null ? [] : [tellObservation]),
                 receiptFailure,
                 requests.failure,
+                completionFailure,
             ]);
+            if (next.kind === "completion-failed") {
+                requests.stopAdmission();
+                throw next.error;
+            }
             if (next.kind === "heart") {
                 heart = next.observation;
                 continue;

package/build/src/git/read-observation.js

@@ -36,12 +36,23 @@ function streamCursor(stream) {
     };
     return { line, exact };
 }
-function batchObjectReader(repository) {
-    const child = spawn(repository.gitPath, ["cat-file", "--batch"], {
+function batchChild(repository) {
+    return spawn(repository.gitPath, ["cat-file", "--batch"], {
         cwd: repository.effectiveCwd,
         stdio: ["pipe", "pipe", "pipe"],
         windowsHide: true,
     });
+}
+function batchError(child, stderr, message, status) {
+    return new GitPlumbingError({
+        stderr: Buffer.concat(stderr),
+        status,
+        message: `git cat-file --batch: ${message}`,
+        pid: child.pid ?? null,
+    });
+}
+function batchObjectReader(repository) {
+    const child = batchChild(repository);
     const cursor = streamCursor(child.stdout);
     const cache = new Map();
     const stderr = [];
@@ -58,12 +69,6 @@ function batchObjectReader(repository) {
     child.stdin.on("error", (error) => {
         spawnError ??= error;
     });
-    const plumbingError = (message, status) => new GitPlumbingError({
-        stderr: Buffer.concat(stderr),
-        status,
-        message: `git cat-file --batch: ${message}`,
-        pid: child.pid ?? null,
-    });
     const write = async (value) => {
         if (spawnError !== null)
             throw spawnError;
@@ -98,7 +103,7 @@ function batchObjectReader(repository) {
                 throw failure;
             child.kill();
             await closed;
-            failure = plumbingError(error instanceof Error ? error.message : String(error), child.exitCode);
+            failure = batchError(child, stderr, error instanceof Error ? error.message : String(error), child.exitCode);
             throw failure;
         }
     };
@@ -126,7 +131,7 @@ function batchObjectReader(repository) {
             child.stdin.end();
         const outcome = await closed;
         if (spawnError !== null || outcome.code !== 0) {
-            throw plumbingError("git cat-file --batch did not close cleanly", outcome.code);
+            throw batchError(child, stderr, "git cat-file --batch did not close cleanly", outcome.code);
         }
     };
     return { objects, close };

package/build/src/kanshi/read.js

@@ -304,34 +304,31 @@ async function readDispatches(observation) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
     }
 }
-export async function observeKanshi(input) {
-    const observedAt = new Date().toISOString();
-    const { world, repo, region, contract } = coordinate(input);
-    const branch = await readBranch(repo);
-    if (repo === undefined) {
-        const contracts = { kind: "absent" };
-        const holders = { kind: "absent" };
-        const observeContract = contractEndpointObserver(contracts);
-        const board = await readTaskWorld(world);
-        const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
-        const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
-        const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
-        return {
-            report: {
-                root: world,
-                observedAt,
-                branch,
-                contracts,
-                tasks,
-                akuma,
-                ...(region === undefined ? {} : { region: { kind: "absent" } }),
-            },
-            aliases,
-        };
-    }
+async function observeWithoutRepo(world, region, observedAt, branch) {
+    const contracts = { kind: "absent" };
+    const holders = { kind: "absent" };
+    const observeContract = contractEndpointObserver(contracts);
+    const board = await readTaskWorld(world);
+    const tasks = world === null ? { kind: "absent" } : readTasks(world, board, holders, observeContract);
+    const aliases = world === null ? { kind: "absent" } : await readAliasBindings(world);
+    const akuma = world === null ? { kind: "absent" } : await joinAkuma(world, observeContract, [], aliases);
+    return {
+        report: {
+            root: world,
+            observedAt,
+            branch,
+            contracts,
+            tasks,
+            akuma,
+            ...(region === undefined ? {} : { region: { kind: "absent" } }),
+        },
+        aliases,
+    };
+}
+async function observeRepo(input) {
+    const { world, repo, region, contract, observedAt, branch } = input;
     try {
-        const repository = scopeForRepo(repo);
-        return await withGitDecodeChannel(repository, (channel) => withGitReadObservation(repository, channel, async (observation) => {
+        return await withGitDecodeChannel(repo, (channel) => withGitReadObservation(repo, channel, async (observation) => {
             const [contractSection, holders, dispatches, regionSection, board] = await Promise.all([
                 readContracts(observation, contract),
                 readHolders(observation),
@@ -385,6 +382,14 @@ export async function observeKanshi(input) {
         };
     }
 }
+export async function observeKanshi(input) {
+    const observedAt = new Date().toISOString();
+    const { world, repo, region, contract } = coordinate(input);
+    const branch = await readBranch(repo);
+    if (repo === undefined)
+        return observeWithoutRepo(world, region, observedAt, branch);
+    return observeRepo({ world, repo: scopeForRepo(repo), region, contract, observedAt, branch });
+}
 export async function kanshi(input) {
     return (await observeKanshi(input)).report;
 }

package/build/src/library/fleet.js

@@ -120,7 +120,8 @@ export async function executeWaitAkuma(input) {
     for (;;) {
         const round = await observeWaitRound(input.path, input.ids, input.signal);
         const settled = round.statuses.map(defaultWaitComplete);
-        const completed = round.statuses.length > 0 && (input.completion === "any" ? settled.some(Boolean) : settled.every(Boolean));
+        const completed = round.statuses.length > 0 &&
+            (input.completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean));
         if (completed || (deadline !== undefined && performance.now() >= deadline)) {
             return {
                 completion: input.completion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.1.2",
+  "version": "4.1.3",
   "files": [
     "build"
   ],