@astrosheep/keiyaku 4.0.5 → 4.0.6

package/build/src/akuma/body.js

@@ -1,159 +1,20 @@
 import { fileURLToPath } from "node:url";
 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 { BodySupervisor, driveTurn, turnRecipe } from "./body-turn.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
-import { BodyRequestPump, clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
+import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 25;
-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;
-}
+export { CONTROL_RESPONSE_MS } from "./body-turn.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
-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 {
-        cwd: admitted?.cwd ?? soul.cwd,
-        options: admitted?.options ?? soul.options,
-        ...(session === undefined ? {} : { session }),
-    };
-}
 async function takeLeash(paths) {
     for (;;) {
         try {
@@ -169,267 +30,6 @@ async function takeLeash(paths) {
         await abortableDelay(LEASH_RETRY_MS);
     }
 }
-async function startTurnDrive(input) {
-    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 = await BodyRequestPump.open({
-        paths: input.paths,
-        parent: input.soul,
-        bodySequence: input.bodySequence,
-        now: input.now,
-        spawn: input.runtimeSpawn,
-        ...(input.upstream === undefined ? {} : { upstream: input.upstream }),
-        signal: input.supervisor.signal,
-    });
-    const driveInput = {
-        body: input.body,
-        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
-        cwd,
-        options,
-        signal: input.supervisor.signal,
-        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 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(),
-            })));
-        }
-        void selected.completion.then(() => requests.stopAdmission());
-        return { turnSequence: turn.sequence, drive: selected, requests, cwd, options,
-            ...(session === undefined ? {} : { resume: session }) };
-    }
-    catch (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 { 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();
-    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" };
-            }
-            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 }));
-            }
-            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.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 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" };
-        }
-        await retireProviderCustody(input, turnSequence, drive);
-        try {
-            await requests.close();
-        }
-        catch { /* preserve the first pump failure */ }
-        return { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) };
-    }
-}
-async function driveTurn(input) {
-    let active;
-    try {
-        const started = await startTurnDrive(input);
-        if ("kind" in started)
-            return started;
-        active = started;
-    }
-    catch (error) {
-        if (!await heartExists(input.paths)) {
-            input.supervisor.cancel("heart-gone");
-            return { kind: "stopped" };
-        }
-        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 };
-        }
-        input.supervisor.cancel("heart-gone");
-        await stopActiveDrive(input, active);
-        return { kind: "stopped" };
-    }
-}
 async function bornSoul(launch, leash, now) {
     const before = await readHeart(launch.paths);
     if (before.soul !== null)
@@ -539,6 +139,8 @@ async function runBodyTurns(input) {
             ...(runtime.upstream === undefined ? {} : { upstream: runtime.upstream }),
             now: runtime.now,
         });
+        if (result.kind === "hung")
+            return;
         if (result.kind === "stopped") {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -564,7 +166,7 @@ export async function driveAkumaBody(launch, adapter, runtime = defaultRuntime()
         const soul = await bornSoul(launch, leash, runtime.now());
         if (soul === null)
             return;
-        const selected = adapter ?? resolveProviderExecution(soul.provider).adapter;
+        const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
         if (!await prepareBodyStart(launch.paths, leash))
             return;
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
@@ -607,23 +209,10 @@ export async function spawnAkumaBody(launch) {
     });
     owned.release();
 }
-export async function runAkumaBody(upstreamFor) {
-    const encoded = process.argv[2];
-    if (encoded === undefined)
-        throw new TypeError("Akuma body launch payload is missing");
-    const launch = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
-    const mappedHome = process.env.KEIYAKU_HOME?.trim();
-    const mappedGitPath = process.env.KEIYAKU_GIT_PATH;
-    if (mappedGitPath !== undefined && mappedGitPath.trim().length === 0) {
-        throw new TypeError("KEIYAKU_GIT_PATH requires a nonblank value");
-    }
-    const configuration = {
-        ...(mappedHome === undefined || mappedHome.length === 0 ? {} : { home: mappedHome }),
-        ...(mappedGitPath === undefined ? {} : { gitPath: mappedGitPath }),
-    };
+export async function runAkumaBody(launch, upstream) {
     await driveAkumaBody(launch, undefined, {
         now: () => new Date().toISOString(),
         spawnChild: spawnAkumaBody,
-        upstream: upstreamFor(launch, configuration),
+        upstream,
     });
 }

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

@@ -159,6 +159,7 @@ export type RequestInput = Readonly<{
     contractId: string;
     message?: string;
     includeDirty: boolean;
+    materializeConflict: boolean;
 }> | Readonly<{
     id: string;
     action: "contract.review";
@@ -249,6 +250,7 @@ export type HeartSnapshot = Readonly<{
     latestKill: KillFact | null;
     stop: StopFact | null;
     pause: PauseFact | null;
+    lastActivityAt: string | null;
 }>;
 export declare function life(input: Readonly<{
     leash: LeashProbe;

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

@@ -1,6 +1,8 @@
 export function life(input) {
+    if (input.body?.hung !== undefined)
+        return "hung";
     if (input.leash === "held")
-        return input.body?.hung === undefined ? "running" : "hung";
+        return "running";
     if (input.body === null || input.body.end === undefined)
         return "untidy";
     if (input.kill?.bodySequence === input.body.sequence)

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

@@ -1,6 +1,6 @@
 import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
 import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
-import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
+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 } from "./storage.js";
@@ -172,11 +172,21 @@ export async function readHeart(paths) {
             latestKill: latestKillFact(heart),
             stop: stopFact(heart),
             pause: pauseFact(heart),
+            lastActivityAt: readLastActivityAt(heart),
         })));
     }
     catch (error) {
         if (isHeartAbsent(error)) {
-            return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null, stop: null, pause: null };
+            return {
+                soul: null,
+                latestBody: null,
+                latestSession: null,
+                pending: [],
+                latestKill: null,
+                stop: null,
+                pause: null,
+                lastActivityAt: null,
+            };
         }
         throw error;
     }

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

@@ -96,6 +96,9 @@ export function sealFact(database) {
     return row === undefined ? null : { evidence: row.evidence, at: row.at };
 }
 export function insertBodyFact(database, input) {
+    if (latestBodyFact(database)?.hung !== undefined) {
+        throw new Error("Akuma successor is permanently gated by hung custody");
+    }
     const result = database.prepare("INSERT INTO bodies(leash_taken_at) VALUES (?)").run(input.leashTakenAt);
     return Number(result.lastInsertRowid);
 }
@@ -151,7 +154,7 @@ export function endBodyFact(database, input) {
 }
 export function markBodyHung(database, input) {
     const result = database.prepare(`UPDATE bodies SET hung_diagnostic = ?, hung_at = ?
-    WHERE sequence = ? AND end IS NULL AND hung_diagnostic IS NULL`)
+    WHERE sequence = ? AND hung_diagnostic IS NULL`)
         .run(input.diagnostic, input.at, input.sequence);
     if (result.changes !== 1)
         throw new Error(`Akuma Body ${input.sequence} cannot record hung custody`);

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
-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 = 19)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 19);\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) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS 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 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

@@ -1,4 +1,4 @@
-const HEART_SCHEMA_VERSION = 19;
+const HEART_SCHEMA_VERSION = 20;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -28,7 +28,8 @@ export const HEART_SCHEMA = `
     hung_at TEXT,
     end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),
     ended_at TEXT,
-    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))
+    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)
+      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))
   ) STRICT;
   CREATE TABLE IF NOT EXISTS sessions (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,

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

@@ -7,5 +7,6 @@ export type ActivityFactSlice = Readonly<{
     lowestRetained: number | null;
     highest: number | null;
 }>;
+export declare function lastActivityAt(database: DatabaseSync): string | null;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;

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

@@ -1,5 +1,24 @@
 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
+      WHEN 'turn-start' THEN started_turn.started_at
+      WHEN 'call' THEN calls.at
+      WHEN 'activity' THEN activity.at
+      WHEN 'tell' THEN tells.recorded_at
+      WHEN 'turn-end' THEN ended_turn.completed_at
+    END AS at
+    FROM timeline
+    LEFT JOIN turns AS started_turn ON timeline.kind = 'turn-start' AND started_turn.sequence = timeline.sequence
+    LEFT JOIN calls ON timeline.kind = 'call' AND calls.sequence = timeline.sequence
+    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();
+    if (row === undefined || row.at === null)
+        return null;
+    return row.at;
+}
 export function pruneActivityFacts(database, limit) {
     const count = database.prepare("SELECT COUNT(*) AS count FROM timeline").get();
     if (count.count <= limit + 500)

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

@@ -0,0 +1,2 @@
+import type { WorldRoot } from "../world.js";
+export declare function stopAkuma(world: WorldRoot): Promise<() => Promise<void>>;