@astrosheep/keiyaku 4.1.0 → 4.1.2

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

@@ -14,7 +14,13 @@ function resumeCoordinate(value) {
     return coordinate;
 }
 export function encodeSessionRow(session) {
-    return [session.provider, encodeResumeCoordinate(session.coordinate), session.cwd, json(session.options), session.admittedAt];
+    return [
+        session.provider,
+        encodeResumeCoordinate(session.coordinate),
+        session.cwd,
+        json(session.options),
+        session.admittedAt,
+    ];
 }
 export function encodeResumeCoordinate(coordinate) {
     return json(encodeCoordinate(coordinate));
@@ -82,7 +88,8 @@ export function sealExists(database) {
     return database.prepare("SELECT singleton FROM seal WHERE singleton = 1").get() !== undefined;
 }
 export function insertSealFact(database, input) {
-    database.prepare("INSERT OR IGNORE INTO seal(singleton, evidence, at) VALUES (1, ?, ?)")
+    database
+        .prepare("INSERT OR IGNORE INTO seal(singleton, evidence, at) VALUES (1, ?, ?)")
         .run(input.evidence, input.at);
 }
 export function deletePauseControl(database) {
@@ -103,25 +110,30 @@ export function insertBodyFact(database, input) {
     return Number(result.lastInsertRowid);
 }
 export function insertSessionFact(database, input) {
-    const result = database.prepare(`INSERT INTO sessions(provider, coordinate_json, cwd, options_json, admitted_at)
-    VALUES (?, ?, ?, ?, ?)`).run(...encodeSessionRow(input));
+    const result = database
+        .prepare(`INSERT INTO sessions(provider, coordinate_json, cwd, options_json, admitted_at)
+    VALUES (?, ?, ?, ?, ?)`)
+        .run(...encodeSessionRow(input));
     return Number(result.lastInsertRowid);
 }
 export function insertActivityFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('activity')").run().lastInsertRowid);
-    database.prepare("INSERT INTO activity(sequence, turn_sequence, event_json, at) VALUES (?, ?, ?, ?)")
+    database
+        .prepare("INSERT INTO activity(sequence, turn_sequence, event_json, at) VALUES (?, ?, ?, ?)")
         .run(sequence, input.turnSequence, encodeActivityEvent(input.event), input.at);
     return sequence;
 }
 export function insertStopControl(database, bodySequence, at) {
-    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
+    database
+        .prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
         .run(json({ bodySequence }), at);
 }
 export function insertPauseControl(database, at) {
     const body = latestBodyFact(database);
     if (body === null)
         throw new Error("Akuma has no Body to interrupt");
-    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', ?, ?)")
+    database
+        .prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', ?, ?)")
         .run(json({ bodySequence: body.sequence }), at);
 }
 export function stopFact(database) {
@@ -145,15 +157,18 @@ export function pauseFact(database) {
     return { bodySequence: value.bodySequence, requestedAt: row.at };
 }
 export function insertKillFact(database, bodySequence, at) {
-    database.prepare("INSERT OR IGNORE INTO kills(body_sequence, evidence, at) VALUES (?, 'killed', ?)")
+    database
+        .prepare("INSERT OR IGNORE INTO kills(body_sequence, evidence, at) VALUES (?, 'killed', ?)")
         .run(bodySequence, at);
 }
 export function endBodyFact(database, input) {
-    database.prepare("UPDATE bodies SET end = ?, ended_at = ? WHERE sequence = ? AND end IS NULL")
+    database
+        .prepare("UPDATE bodies SET end = ?, ended_at = ? WHERE sequence = ? AND end IS NULL")
         .run(input.end, input.at, input.sequence);
 }
 export function markBodyHung(database, input) {
-    const result = database.prepare(`UPDATE bodies SET hung_diagnostic = ?, hung_at = ?
+    const result = database
+        .prepare(`UPDATE bodies SET hung_diagnostic = ?, hung_at = ?
     WHERE sequence = ? AND hung_diagnostic IS NULL`)
         .run(input.diagnostic, input.at, input.sequence);
     if (result.changes !== 1)
@@ -161,11 +176,13 @@ export function markBodyHung(database, input) {
 }
 export function insertTurnStartFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('turn-start')").run().lastInsertRowid);
-    database.prepare("INSERT INTO turns(sequence, body_sequence, started_at) VALUES (?, ?, ?)")
+    database
+        .prepare("INSERT INTO turns(sequence, body_sequence, started_at) VALUES (?, ?, ?)")
         .run(sequence, input.bodySequence, input.startedAt);
     if (input.call !== undefined) {
         const callSequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('call')").run().lastInsertRowid);
-        database.prepare("INSERT INTO calls(sequence, turn_sequence, body, at) VALUES (?, ?, ?, ?)")
+        database
+            .prepare("INSERT INTO calls(sequence, turn_sequence, body, at) VALUES (?, ?, ?, ?)")
             .run(callSequence, sequence, input.call, input.startedAt);
     }
     return { kind: "turn-start", sequence, bodySequence: input.bodySequence, startedAt: input.startedAt };
@@ -173,62 +190,83 @@ export function insertTurnStartFact(database, input) {
 export function insertTurnEndFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('turn-end')").run().lastInsertRowid);
     const result = input.outcome.kind === "answered"
-        ? database.prepare(`UPDATE turns SET end_sequence = ?, outcome = 'answered', history_id = ?,
-        session_json = ?, answer = ?, completed_at = ? WHERE sequence = ? AND end_sequence IS NULL`).run(sequence, input.outcome.historyId ?? null, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt, input.turnSequence)
-        : database.prepare(`UPDATE turns SET end_sequence = ?, outcome = 'failed', diagnostic = ?, completed_at = ?
-        WHERE sequence = ? AND end_sequence IS NULL`).run(sequence, input.outcome.diagnostic, input.completedAt, input.turnSequence);
+        ? database
+            .prepare(`UPDATE turns SET end_sequence = ?, outcome = 'answered', history_id = ?,
+        session_json = ?, answer = ?, completed_at = ? WHERE sequence = ? AND end_sequence IS NULL`)
+            .run(sequence, input.outcome.historyId ?? null, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt, input.turnSequence)
+        : database
+            .prepare(`UPDATE turns SET end_sequence = ?, outcome = 'failed', diagnostic = ?, completed_at = ?
+        WHERE sequence = ? AND end_sequence IS NULL`)
+            .run(sequence, input.outcome.diagnostic, input.completedAt, input.turnSequence);
     if (result.changes !== 1)
         throw new Error(`Akuma Turn ${input.turnSequence} is not open`);
     return { ...input, kind: "turn-end", sequence };
 }
 export function finishBodyFact(database, input) {
-    database.prepare("UPDATE bodies SET end = 'exited', ended_at = ? WHERE sequence = ? AND end IS NULL")
+    database
+        .prepare("UPDATE bodies SET end = 'exited', ended_at = ? WHERE sequence = ? AND end IS NULL")
         .run(input.at, input.sequence);
 }
 export function latestBodyFact(database) {
-    const row = database.prepare(`SELECT sequence, leash_taken_at, hung_diagnostic, hung_at, end, ended_at
-    FROM bodies ORDER BY sequence DESC LIMIT 1`).get();
+    const row = database
+        .prepare(`SELECT sequence, leash_taken_at, hung_diagnostic, hung_at, end, ended_at
+    FROM bodies ORDER BY sequence DESC LIMIT 1`)
+        .get();
     return row === undefined ? null : decodeBodyRow(row);
 }
 export function latestSessionFact(database) {
-    const row = database.prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
-    FROM sessions ORDER BY sequence DESC LIMIT 1`).get();
+    const row = database
+        .prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
+    FROM sessions ORDER BY sequence DESC LIMIT 1`)
+        .get();
     return row === undefined ? null : decodeSessionRow(row);
 }
 export function sessionFactForCoordinate(database, coordinate) {
-    const row = database.prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
+    const row = database
+        .prepare(`SELECT sequence, provider, coordinate_json, cwd, options_json, admitted_at
     FROM sessions WHERE coordinate_json = ? ORDER BY sequence DESC LIMIT 1`)
         .get(encodeResumeCoordinate(coordinate));
     return row === undefined ? null : decodeSessionRow(row);
 }
 export function latestKillFact(database) {
-    const row = database.prepare(`SELECT sequence, body_sequence, evidence, at
-    FROM kills ORDER BY sequence DESC LIMIT 1`).get();
-    return row === undefined ? null : {
-        sequence: row.sequence,
-        bodySequence: row.body_sequence,
-        evidence: row.evidence,
-        at: row.at,
-    };
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, evidence, at
+    FROM kills ORDER BY sequence DESC LIMIT 1`)
+        .get();
+    return row === undefined
+        ? null
+        : {
+            sequence: row.sequence,
+            bodySequence: row.body_sequence,
+            evidence: row.evidence,
+            at: row.at,
+        };
 }
 export function killFactForBody(database, bodySequence) {
-    const row = database.prepare(`SELECT sequence, body_sequence, evidence, at
-    FROM kills WHERE body_sequence = ?`).get(bodySequence);
-    return row === undefined ? null : {
-        sequence: row.sequence,
-        bodySequence: row.body_sequence,
-        evidence: row.evidence,
-        at: row.at,
-    };
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, evidence, at
+    FROM kills WHERE body_sequence = ?`)
+        .get(bodySequence);
+    return row === undefined
+        ? null
+        : {
+            sequence: row.sequence,
+            bodySequence: row.body_sequence,
+            evidence: row.evidence,
+            at: row.at,
+        };
 }
 export function lastAnsweredTurnFact(database) {
-    const row = database.prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
     session_json, answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' ORDER BY end_sequence DESC LIMIT 1`)
         .get();
     return row === undefined ? null : decodeTurnRow(row);
 }
 export function answeredTurnFact(database, historyId) {
-    const row = database.prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
-    session_json, answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND history_id = ?`).get(historyId);
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
+    session_json, answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND history_id = ?`)
+        .get(historyId);
     return row === undefined ? null : decodeTurnRow(row);
 }

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

@@ -1,5 +1,5 @@
 import { parseAkuId } from "../identity.js";
-import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint, } from "../provider-recipe.js";
+import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint } from "../provider-recipe.js";
 import { effectiveAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)

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

@@ -2,6 +2,7 @@ import { DatabaseSync } from "node:sqlite";
 import type { AkumaPaths } from "../identity.js";
 import type { BodyFact, LeashProbe, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
 import { sealFact } from "./rows.js";
+export declare function watchHeart(paths: AkumaPaths, signal: AbortSignal): Promise<AsyncGenerator<void>>;
 export declare class HeartAbsentError extends Error {
     readonly path: string;
     constructor(path: string, options?: ErrorOptions);

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

@@ -1,5 +1,7 @@
 import { DatabaseSync } from "node:sqlite";
+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 { deletePauseControl, deleteStopControl, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
@@ -8,6 +10,58 @@ import { pruneActivityFacts } from "./timeline.js";
 import { insertSoulFact, soulFact } from "./soul.js";
 const ACTIVITY_LIMIT = 5_000;
 const SQLITE_CANTOPEN = 14;
+export async function watchHeart(paths, signal) {
+    const heart = basename(paths.heart);
+    const changes = [];
+    let failure;
+    let wake;
+    // fs.watch opens the directory synchronously. Its throw is therefore the
+    // observer's ready/failure boundary, before a waker can spawn a child.
+    const watcher = watchDirectory(dirname(paths.heart), { signal }, (_event, filename) => {
+        const name = filename?.toString();
+        if (name === undefined || name === heart || name === `${heart}-wal`) {
+            changes.push(undefined);
+            wake?.();
+        }
+    });
+    watcher.on("error", (error) => {
+        failure = error;
+        wake?.();
+    });
+    const abort = () => {
+        wake?.();
+        watcher.close();
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    return (async function* () {
+        try {
+            for (;;) {
+                if (changes.length > 0) {
+                    changes.shift();
+                    yield;
+                    continue;
+                }
+                if (failure !== undefined)
+                    throw failure;
+                if (signal.aborted)
+                    return;
+                await new Promise((resolve) => {
+                    wake = resolve;
+                });
+                wake = undefined;
+            }
+        }
+        catch (error) {
+            if (signal.aborted && error.name === "AbortError")
+                return;
+            throw error;
+        }
+        finally {
+            signal.removeEventListener("abort", abort);
+            watcher.close();
+        }
+    })();
+}
 export class HeartAbsentError extends Error {
     path;
     constructor(path, options) {
@@ -22,16 +76,17 @@ export function isHeartAbsent(error) {
 function isBusy(error) {
     const value = error;
     const message = String(value?.message ?? "").toLowerCase();
-    return value?.code === "ERR_SQLITE_BUSY" || value?.code === "ERR_SQLITE_LOCKED"
-        || value?.errcode === 5 || message.includes("database is locked") || message.includes("database is busy");
+    return (value?.code === "ERR_SQLITE_BUSY" ||
+        value?.code === "ERR_SQLITE_LOCKED" ||
+        value?.errcode === 5 ||
+        message.includes("database is locked") ||
+        message.includes("database is busy"));
 }
 async function openExistingDatabase(path, timeout) {
     const uri = pathToFileURL(path);
     uri.searchParams.set("mode", "rw");
     try {
-        return timeout === undefined
-            ? new DatabaseSync(uri.href)
-            : new DatabaseSync(uri.href, { timeout });
+        return timeout === undefined ? new DatabaseSync(uri.href) : new DatabaseSync(uri.href, { timeout });
     }
     catch (error) {
         if (error.errcode === SQLITE_CANTOPEN) {
@@ -80,7 +135,9 @@ export function transaction(database, body) {
         try {
             database.exec("ROLLBACK");
         }
-        catch { /* preserve the adjudication failure */ }
+        catch {
+            /* preserve the adjudication failure */
+        }
         throw error;
     }
 }
@@ -95,7 +152,9 @@ export function readTransaction(database, body) {
         try {
             database.exec("ROLLBACK");
         }
-        catch { /* preserve the original failure */ }
+        catch {
+            /* preserve the original failure */
+        }
         throw error;
     }
 }
@@ -153,7 +212,7 @@ export class HeldAkumaLeash {
     async sealIfUnborn(paths, input) {
         if (sealExists(this.database))
             return "sealed";
-        if (await withHeart(paths, (heart) => soulFact(heart)) !== null)
+        if ((await withHeart(paths, (heart) => soulFact(heart))) !== null)
             return "born";
         insertSealFact(this.database, input);
         this.database.exec("COMMIT");
@@ -164,8 +223,12 @@ export class HeldAkumaLeash {
     readSeal() {
         return sealFact(this.database);
     }
-    async clearPause(paths) { await withHeart(paths, deletePauseControl); }
-    async clearStop(paths) { await withHeart(paths, deleteStopControl); }
+    async clearPause(paths) {
+        await withHeart(paths, deletePauseControl);
+    }
+    async clearStop(paths) {
+        await withHeart(paths, deleteStopControl);
+    }
     async recordBody(paths, input) {
         if (this.closed || this.bodySequence !== undefined)
             throw new Error("Akuma leash cannot start another Body");
@@ -186,7 +249,9 @@ export class HeldAkumaLeash {
                 if (expectedBodySequence === undefined)
                     return null;
                 const existing = killFactForBody(heart, expectedBodySequence);
-                return existing === null ? null : { target: { bodySequence: expectedBodySequence, requestedAt: existing.at }, result: "already-killed" };
+                return existing === null
+                    ? null
+                    : { target: { bodySequence: expectedBodySequence, requestedAt: existing.at }, result: "already-killed" };
             }
             if (expectedBodySequence !== undefined && target.bodySequence !== expectedBodySequence) {
                 throw new Error("Akuma stop target changed while kill was in progress");

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

@@ -15,8 +15,10 @@ export const pendingTellSequencesSql = `SELECT tells.sequence FROM tells WHERE $
 export const pendingTellProtectionSql = `SELECT d.turn_sequence FROM tell_deliveries d
   JOIN tells ON tells.id = d.tell_id WHERE ${tellStateSql} = 'pending'`;
 function tellDeliveries(database, id) {
-    const rows = database.prepare(`SELECT turn_sequence, route, receipt, delivered_at FROM tell_deliveries
-    WHERE tell_id = ? ORDER BY sequence`).all(id);
+    const rows = database
+        .prepare(`SELECT turn_sequence, route, receipt, delivered_at FROM tell_deliveries
+    WHERE tell_id = ? ORDER BY sequence`)
+        .all(id);
     return rows.map((row) => row.receipt == null
         ? { turnSequence: row.turn_sequence, route: row.route, deliveredAt: row.delivered_at }
         : { turnSequence: row.turn_sequence, route: row.route, receipt: row.receipt, deliveredAt: row.delivered_at });
@@ -33,47 +35,62 @@ function decodeTellRow(database, row) {
     };
 }
 export function decodeTellAtSequence(database, sequence) {
-    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
-    FROM tells WHERE sequence = ?`).get(sequence);
+    const row = database
+        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE sequence = ?`)
+        .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing tell ${sequence}`);
     return decodeTellRow(database, row);
 }
 export function insertTellFact(database, tell) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('tell')").run().lastInsertRowid);
-    database.prepare("INSERT INTO tells(id, sequence, body, recorded_at) VALUES (?, ?, ?, ?)")
+    database
+        .prepare("INSERT INTO tells(id, sequence, body, recorded_at) VALUES (?, ?, ?, ?)")
         .run(tell.id, sequence, tell.body, tell.recordedAt);
     return sequence;
 }
 export function tellFact(database, id) {
-    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
-    FROM tells WHERE id = ?`).get(id);
+    const row = database
+        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE id = ?`)
+        .get(id);
     return row === undefined ? null : decodeTellRow(database, row);
 }
 export function insertTellDeliveryFact(database, input) {
-    const result = database.prepare(`INSERT OR IGNORE INTO tell_deliveries(
+    const result = database
+        .prepare(`INSERT OR IGNORE INTO tell_deliveries(
     tell_id, route, turn_sequence, fence, receipt, delivered_at
-  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.tellId, input.route, input.turnSequence, input.fence, input.route === "live" ? input.receipt : null, input.deliveredAt);
-    const row = database.prepare(`SELECT route, receipt FROM tell_deliveries
+  ) VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(input.tellId, input.route, input.turnSequence, input.fence, input.route === "live" ? input.receipt : null, input.deliveredAt);
+    const row = database
+        .prepare(`SELECT route, receipt FROM tell_deliveries
     WHERE tell_id = ? AND turn_sequence = ? AND fence = ?`)
         .get(input.tellId, input.turnSequence, input.fence);
-    if (row === undefined || (result.changes === 0
-        && (row.route !== input.route || row.receipt !== (input.route === "live" ? input.receipt : null)))) {
+    if (row === undefined ||
+        (result.changes === 0 &&
+            (row.route !== input.route || row.receipt !== (input.route === "live" ? input.receipt : null)))) {
         throw new Error(`tell delivery ${input.tellId} has conflicting evidence`);
     }
 }
 export function insertTellReceiptFact(database, input) {
-    database.prepare(`INSERT OR IGNORE INTO tell_receipts(
+    database
+        .prepare(`INSERT OR IGNORE INTO tell_receipts(
     evidence, tell_id, turn_sequence, fence, kind, received_at
-  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.evidence, input.evidence === "exact" ? input.tellId : null, input.evidence === "fence" ? input.turnSequence : null, input.evidence === "fence" ? input.fence : null, input.kind, input.receivedAt);
+  ) VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(input.evidence, input.evidence === "exact" ? input.tellId : null, input.evidence === "fence" ? input.turnSequence : null, input.evidence === "fence" ? input.fence : null, input.kind, input.receivedAt);
 }
 export function tellIdsForFence(database, turnSequence, fence) {
-    return database.prepare(`SELECT tell_id FROM tell_deliveries
+    return database
+        .prepare(`SELECT tell_id FROM tell_deliveries
     WHERE turn_sequence = ? AND fence = ? ORDER BY sequence`)
-        .all(turnSequence, fence).map((row) => row.tell_id);
+        .all(turnSequence, fence)
+        .map((row) => row.tell_id);
 }
 export function pendingTellFacts(database) {
-    const rows = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
-    WHERE ${tellStateSql} = 'pending' ORDER BY sequence`).all();
+    const rows = database
+        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
+    WHERE ${tellStateSql} = 'pending' ORDER BY sequence`)
+        .all();
     return rows.map((row) => decodeTellRow(database, row));
 }

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

@@ -1,7 +1,8 @@
 import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
 import { decodeTellAtSequence, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
 export function lastActivityAt(database) {
-    const row = database.prepare(`SELECT CASE timeline.kind
+    const row = database
+        .prepare(`SELECT CASE timeline.kind
       WHEN 'turn-start' THEN started_turn.started_at
       WHEN 'call' THEN calls.at
       WHEN 'activity' THEN activity.at
@@ -14,7 +15,8 @@ export function lastActivityAt(database) {
     LEFT JOIN activity ON timeline.kind = 'activity' AND activity.sequence = timeline.sequence
     LEFT JOIN tells ON timeline.kind = 'tell' AND tells.sequence = timeline.sequence
     LEFT JOIN turns AS ended_turn ON timeline.kind = 'turn-end' AND ended_turn.end_sequence = timeline.sequence
-    ORDER BY timeline.sequence DESC LIMIT 1`).get();
+    ORDER BY timeline.sequence DESC LIMIT 1`)
+        .get();
     if (row === undefined || row.at === null)
         return null;
     return row.at;
@@ -23,11 +25,13 @@ export function pruneActivityFacts(database, limit) {
     const count = database.prepare("SELECT COUNT(*) AS count FROM timeline").get();
     if (count.count <= limit + 500)
         return;
-    const cutoff = database.prepare(`SELECT sequence FROM timeline ORDER BY sequence DESC LIMIT 1 OFFSET ?`)
+    const cutoff = database
+        .prepare(`SELECT sequence FROM timeline ORDER BY sequence DESC LIMIT 1 OFFSET ?`)
         .get(limit - 1);
     if (cutoff === undefined)
         return;
-    database.prepare(`WITH protected_turns(sequence) AS (
+    database
+        .prepare(`WITH protected_turns(sequence) AS (
       SELECT sequence FROM turns WHERE end_sequence IS NULL
       UNION SELECT turn_sequence FROM calls WHERE sequence >= ?
       UNION SELECT turn_sequence FROM activity WHERE sequence >= ?
@@ -43,7 +47,8 @@ export function pruneActivityFacts(database, limit) {
         .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
 }
 function turn(database, sequence) {
-    const row = database.prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
     history_id, session_json, answer, diagnostic, completed_at FROM turns WHERE sequence = ?`)
         .get(sequence);
     if (row === undefined)
@@ -51,7 +56,8 @@ function turn(database, sequence) {
     return decodeTurnRow(row);
 }
 function turnStart(database, sequence) {
-    const row = database.prepare("SELECT sequence, body_sequence, started_at FROM turns WHERE sequence = ?")
+    const row = database
+        .prepare("SELECT sequence, body_sequence, started_at FROM turns WHERE sequence = ?")
         .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing Turn ${sequence}`);
@@ -68,14 +74,16 @@ function decodeTimelineRow(database, row) {
         return fact;
     }
     if (row.kind === "call") {
-        const value = database.prepare("SELECT sequence, turn_sequence, body, at FROM calls WHERE sequence = ?")
+        const value = database
+            .prepare("SELECT sequence, turn_sequence, body, at FROM calls WHERE sequence = ?")
             .get(row.sequence);
         if (value === undefined)
             throw new Error(`Akuma timeline references missing call ${row.sequence}`);
         return decodeCallRow(value);
     }
     if (row.kind === "activity") {
-        const value = database.prepare("SELECT sequence, turn_sequence, event_json, at FROM activity WHERE sequence = ?")
+        const value = database
+            .prepare("SELECT sequence, turn_sequence, event_json, at FROM activity WHERE sequence = ?")
             .get(row.sequence);
         if (value === undefined)
             throw new Error(`Akuma timeline references missing activity ${row.sequence}`);
@@ -84,9 +92,9 @@ function decodeTimelineRow(database, row) {
     return decodeTellAtSequence(database, row.sequence);
 }
 export function activityFactSlice(database) {
-    const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline")
-        .get();
-    const rows = database.prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
+    const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline").get();
+    const rows = database
+        .prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
         .all();
     return {
         rows: rows.map((row) => decodeTimelineRow(database, row)),

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

@@ -7,6 +7,7 @@ export type AkumaPaths = Readonly<{
     heart: string;
     leash: string;
     log: string;
+    requests: string;
 }>;
 export type AllocatedAkuma = Readonly<{
     id: AkuId;

package/build/src/akuma/identity.js

@@ -39,6 +39,7 @@ export function akumaPaths(input) {
         heart: join(directory, "heart.db"),
         leash: join(directory, "leash.db"),
         log: join(directory, "stdio.log"),
+        requests: join(directory, "requests"),
     };
 }
 export function akuIdFromDirectoryName(name) {

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

@@ -1,6 +1,6 @@
 import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
-export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { Akuma, AkumaHandle, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 export type { AkumaCallInput } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export type { AllowedAction, AllowedActions } from "./allowed.js";
@@ -9,9 +9,9 @@ export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise
 export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
-export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, UnbornAkumaListRow, } from "./akuma.js";
+export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, TellWake, UnbornAkumaListRow, } from "./akuma.js";
 export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";
-export type { KillEvidence, ResumeCoordinate, TurnFact, } from "./heart/index.js";
+export type { KillEvidence, ResumeCoordinate, TurnFact } from "./heart/index.js";
 export type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";

package/build/src/akuma/index.js

@@ -1,6 +1,6 @@
 import { readSoul } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
-export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { Akuma, AkumaHandle, AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";
 export async function probeBornAkuma(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));