@astrosheep/keiyaku 4.0.0 → 4.0.2

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

@@ -1,27 +1,15 @@
 import type { DatabaseSync } from "node:sqlite";
 import type { AkuId } from "../identity.js";
-import type { BodyEnd, BodyFact, Collar, DeathFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, Soul, TellFact, TellState, TurnFact } from "./facts.js";
-export type SoulRow = Readonly<{
-    id: string;
-    archetype: string;
-    description: string | null;
-    provider_json: string;
-    options_json: string;
-    cwd: string;
-    origin_json: string;
-    confinement_json: string;
-    created_at: string;
-}>;
+import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 export type SealRow = Readonly<{
     evidence: string;
     at: string;
 }>;
 export type BodyRow = Readonly<{
     sequence: number;
-    pid: number;
-    process_group: number;
-    spawned_at: string;
     leash_taken_at: string;
+    hung_diagnostic: string | null;
+    hung_at: string | null;
     end: BodyEnd | null;
     ended_at: string | null;
 }>;
@@ -36,18 +24,20 @@ export type SessionRow = Readonly<{
 export type TurnRow = Readonly<{
     sequence: number;
     body_sequence: number;
-    outcome: "answered" | "failed";
+    started_at: string;
+    end_sequence: number | null;
+    outcome: "answered" | "failed" | null;
     history_id: string | null;
     session_json: string | null;
     answer: string | null;
     diagnostic: string | null;
-    completed_at: string;
+    completed_at: string | null;
 }>;
-export type TellRow = Readonly<{
-    id: string;
+export type CallRow = Readonly<{
+    sequence: number;
+    turn_sequence: number;
     body: string;
-    state: TellState;
-    recorded_at: string;
+    at: string;
 }>;
 export type RequestRow = Readonly<{
     sequence: number;
@@ -65,80 +55,52 @@ export type RequestRow = Readonly<{
 }>;
 export type ActivityRow = Readonly<{
     sequence: number;
-    body_sequence: number;
+    turn_sequence: number;
     event_json: string;
     at: string;
 }>;
 export type ActivityFact = Readonly<{
+    kind: "activity";
     sequence: number;
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
 }>;
-export type ActivityFactSlice = Readonly<{
-    rows: readonly ActivityFact[];
-    lowestRetained: number | null;
-    highest: number | null;
-}>;
-export type DeathRow = Readonly<{
-    value_json: string;
+export type KillRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    evidence: "killed";
     at: string;
 }>;
-export declare function encodeSoulRow(soul: Soul): readonly [
-    AkuId,
-    string,
-    string | null,
-    string,
-    string,
-    string,
-    string,
-    string,
-    string
-];
-export declare function decodeSoulRow(row: SoulRow): Soul;
 export declare function encodeSessionRow(session: Omit<SessionFact, "sequence">): readonly [string, string, string, string, string];
 export declare function encodeResumeCoordinate(coordinate: ResumeCoordinate): string;
 export declare function decodeSessionRow(row: SessionRow): SessionFact;
 export declare function decodeBodyRow(row: BodyRow): BodyFact;
 export declare function decodeTurnRow(row: TurnRow): TurnFact;
-export declare function decodeTellRow(row: TellRow): TellFact;
+export declare function decodeCallRow(row: CallRow): CallFact;
 export declare function decodeRequestRow(row: RequestRow): RequestFact;
 export declare function encodeActivityEvent(event: unknown): string;
 export declare function decodeActivityRow(row: ActivityRow): ActivityFact;
-export declare function encodeDeathRow(death: DeathFact): string;
-export declare function decodeDeathRow(row: DeathRow): DeathFact;
-export declare function soulFact(database: DatabaseSync): Soul | null;
 export declare function sealExists(database: DatabaseSync): boolean;
-export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
 export declare function insertSealFact(database: DatabaseSync, input: Readonly<{
     evidence: string;
     at: string;
 }>): void;
 export declare function deletePauseControl(database: DatabaseSync): void;
+export declare function deleteStopControl(database: DatabaseSync): void;
 export declare function sealFact(database: DatabaseSync): Readonly<{
     evidence: string;
     at: string;
 }> | null;
 export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
-    collar: Collar;
     leashTakenAt: string;
 }>): number;
 export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
 export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
-    bodySequence: number;
+    turnSequence: number;
     event: unknown;
     at: string;
 }>): number;
-export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
-export declare function activityFactSlice(database: DatabaseSync, input: Readonly<{
-    before?: number;
-    since?: number;
-    limit: number;
-}>): ActivityFactSlice;
-export declare function deathExists(database: DatabaseSync): boolean;
-export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "state">): void;
-export declare function tellState(database: DatabaseSync, id: string): TellState | null;
-export declare function updateTellState(database: DatabaseSync, id: string, state: TellState): void;
 export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
     admittedAt: string;
 }>): void;
@@ -148,31 +110,27 @@ export declare function updateRequestReserved(database: DatabaseSync, id: string
 export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
 export declare function updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
 export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
-export declare function insertStopControl(database: DatabaseSync, at: string): void;
+export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function insertPauseControl(database: DatabaseSync, at: string): void;
-export declare function stopExists(database: DatabaseSync): boolean;
-export declare function pauseExists(database: DatabaseSync): boolean;
-export declare function deleteAbandonedControls(database: DatabaseSync): void;
-export declare function insertDeathFact(database: DatabaseSync, death: DeathFact): void;
-export declare function voidTellsByDeath(database: DatabaseSync): void;
-export declare function voidRequestsByDeath(database: DatabaseSync, evidence: string): void;
+export declare function stopFact(database: DatabaseSync): StopFact | null;
+export declare function pauseFact(database: DatabaseSync): PauseFact | null;
+export declare function insertKillFact(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function endBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;
     end: BodyEnd;
     at: string;
 }>): void;
-type AnsweredTurn = Omit<TurnFact, "sequence" | "outcome"> & Readonly<{
-    outcome: Extract<TurnFact["outcome"], {
-        kind: "answered";
-    }>;
-}>;
-export declare function insertAnsweredTurnFact(database: DatabaseSync, input: AnsweredTurn): number;
-type FailedTurn = Omit<TurnFact, "sequence" | "outcome"> & Readonly<{
-    outcome: Extract<TurnFact["outcome"], {
-        kind: "failed";
-    }>;
-}>;
-export declare function insertFailedTurnFact(database: DatabaseSync, input: FailedTurn): number;
+export declare function markBodyHung(database: DatabaseSync, input: Readonly<{
+    sequence: number;
+    diagnostic: string;
+    at: string;
+}>): void;
+export declare function insertTurnStartFact(database: DatabaseSync, input: Readonly<{
+    bodySequence: number;
+    startedAt: string;
+    call?: string;
+}>): TurnStartFact;
+export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
 export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;
     at: string;
@@ -180,10 +138,7 @@ export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
 export declare function latestBodyFact(database: DatabaseSync): BodyFact | null;
 export declare function latestSessionFact(database: DatabaseSync): SessionFact | null;
 export declare function sessionFactForCoordinate(database: DatabaseSync, coordinate: ResumeCoordinate): SessionFact | null;
-export declare function pendingTellFacts(database: DatabaseSync): readonly TellFact[];
-export declare function deathFact(database: DatabaseSync): DeathFact | null;
-export declare function historyFacts(database: DatabaseSync): readonly TurnFact[];
+export declare function latestKillFact(database: DatabaseSync): KillFact | null;
+export declare function killFactForBody(database: DatabaseSync, bodySequence: number): KillFact | null;
 export declare function lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
-export declare function latestTurnFact(database: DatabaseSync): TurnFact | null;
 export declare function answeredTurnFact(database: DatabaseSync, historyId: string): TurnFact | null;
-export {};

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

@@ -1,3 +1,4 @@
+import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
 function json(value) {
     return JSON.stringify(value);
 }
@@ -6,43 +7,23 @@ function parsed(value) {
         throw new Error("Akuma authority contains non-text JSON");
     return JSON.parse(value);
 }
-export function encodeSoulRow(soul) {
-    return [
-        soul.id,
-        soul.archetype,
-        soul.description ?? null,
-        json(soul.provider),
-        json(soul.options),
-        soul.cwd,
-        json(soul.origin),
-        json(soul.confinement),
-        soul.createdAt,
-    ];
-}
-export function decodeSoulRow(row) {
-    return {
-        id: row.id,
-        archetype: row.archetype,
-        ...(row.description === null ? {} : { description: row.description }),
-        provider: parsed(row.provider_json),
-        options: parsed(row.options_json),
-        cwd: row.cwd,
-        origin: parsed(row.origin_json),
-        confinement: parsed(row.confinement_json),
-        createdAt: row.created_at,
-    };
+function resumeCoordinate(value) {
+    const coordinate = decodeResumeCoordinate(value);
+    if (coordinate === null)
+        throw new Error("Akuma authority contains an invalid resume coordinate");
+    return coordinate;
 }
 export function encodeSessionRow(session) {
-    return [session.provider, json(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(coordinate);
+    return json(encodeCoordinate(coordinate));
 }
 export function decodeSessionRow(row) {
     return {
         sequence: row.sequence,
         provider: row.provider,
-        coordinate: parsed(row.coordinate_json),
+        coordinate: resumeCoordinate(parsed(row.coordinate_json)),
         cwd: row.cwd,
         options: parsed(row.options_json),
         admittedAt: row.admitted_at,
@@ -51,29 +32,39 @@ export function decodeSessionRow(row) {
 export function decodeBodyRow(row) {
     return {
         sequence: row.sequence,
-        collar: { pid: row.pid, processGroup: row.process_group, spawnedAt: row.spawned_at },
         leashTakenAt: row.leash_taken_at,
+        ...(row.hung_diagnostic === null ? {} : { hung: { diagnostic: row.hung_diagnostic, at: row.hung_at } }),
         ...(row.end === null ? {} : { end: row.end }),
         ...(row.ended_at === null ? {} : { endedAt: row.ended_at }),
     };
 }
 export function decodeTurnRow(row) {
-    return {
+    const start = {
+        kind: "turn-start",
         sequence: row.sequence,
         bodySequence: row.body_sequence,
+        startedAt: row.started_at,
+    };
+    if (row.outcome === null)
+        return start;
+    const end = {
+        kind: "turn-end",
+        sequence: row.end_sequence,
+        turnSequence: row.sequence,
         outcome: row.outcome === "answered"
             ? {
                 kind: "answered",
-                historyId: row.history_id,
-                session: parsed(row.session_json),
+                ...(row.history_id === null ? {} : { historyId: row.history_id }),
+                session: resumeCoordinate(parsed(row.session_json)),
                 answer: row.answer,
             }
             : { kind: "failed", diagnostic: row.diagnostic },
         completedAt: row.completed_at,
     };
+    return { ...start, end };
 }
-export function decodeTellRow(row) {
-    return { id: row.id, body: row.body, state: row.state, recordedAt: row.recorded_at };
+export function decodeCallRow(row) {
+    return { kind: "call", sequence: row.sequence, turnSequence: row.turn_sequence, body: row.body, at: row.at };
 }
 export function decodeRequestRow(row) {
     const input = {
@@ -99,30 +90,16 @@ export function encodeActivityEvent(event) {
 }
 export function decodeActivityRow(row) {
     return {
+        kind: "activity",
         sequence: row.sequence,
-        bodySequence: row.body_sequence,
+        turnSequence: row.turn_sequence,
         event: parsed(row.event_json),
         at: row.at,
     };
 }
-export function encodeDeathRow(death) {
-    return json({ evidence: death.evidence });
-}
-export function decodeDeathRow(row) {
-    return { evidence: parsed(row.value_json).evidence, at: row.at };
-}
-export function soulFact(database) {
-    const row = database.prepare(`SELECT id, archetype, description, provider_json, options_json, cwd,
-    origin_json, confinement_json, created_at FROM soul WHERE singleton = 1`).get();
-    return row === undefined ? null : decodeSoulRow(row);
-}
 export function sealExists(database) {
     return database.prepare("SELECT singleton FROM seal WHERE singleton = 1").get() !== undefined;
 }
-export function insertSoulFact(database, soul) {
-    database.prepare(`INSERT INTO soul(singleton, id, archetype, description, provider_json, options_json, cwd, origin_json, confinement_json, created_at)
-    VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(...encodeSoulRow(soul));
-}
 export function insertSealFact(database, input) {
     database.prepare("INSERT OR IGNORE INTO seal(singleton, evidence, at) VALUES (1, ?, ?)")
         .run(input.evidence, input.at);
@@ -130,13 +107,15 @@ export function insertSealFact(database, input) {
 export function deletePauseControl(database) {
     database.prepare("DELETE FROM control WHERE kind = 'pause'").run();
 }
+export function deleteStopControl(database) {
+    database.prepare("DELETE FROM control WHERE kind = 'stop'").run();
+}
 export function sealFact(database) {
     const row = database.prepare("SELECT evidence, at FROM seal WHERE singleton = 1").get();
     return row === undefined ? null : { evidence: row.evidence, at: row.at };
 }
 export function insertBodyFact(database, input) {
-    const result = database.prepare(`INSERT INTO bodies(pid, process_group, spawned_at, leash_taken_at)
-    VALUES (?, ?, ?, ?)`).run(input.collar.pid, input.collar.processGroup, input.collar.spawnedAt, input.leashTakenAt);
+    const result = database.prepare("INSERT INTO bodies(leash_taken_at) VALUES (?)").run(input.leashTakenAt);
     return Number(result.lastInsertRowid);
 }
 export function insertSessionFact(database, input) {
@@ -145,53 +124,10 @@ export function insertSessionFact(database, input) {
     return Number(result.lastInsertRowid);
 }
 export function insertActivityFact(database, input) {
-    const result = database.prepare("INSERT INTO activity(body_sequence, event_json, at) VALUES (?, ?, ?)")
-        .run(input.bodySequence, encodeActivityEvent(input.event), input.at);
-    return Number(result.lastInsertRowid);
-}
-export function pruneActivityFacts(database, limit) {
-    database.prepare(`DELETE FROM activity
-    WHERE sequence NOT IN (SELECT sequence FROM activity ORDER BY sequence DESC LIMIT ?)`)
-        .run(limit);
-}
-export function activityFactSlice(database, input) {
-    const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM activity")
-        .get();
-    let rows;
-    if (input.before !== undefined) {
-        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM (
-      SELECT sequence, body_sequence, event_json, at FROM activity
-      WHERE sequence < ? ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.before, input.limit);
-    }
-    else if (input.since !== undefined) {
-        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM activity
-      WHERE sequence > ? ORDER BY sequence LIMIT ?`).all(input.since, input.limit);
-    }
-    else {
-        rows = database.prepare(`SELECT sequence, body_sequence, event_json, at FROM (
-      SELECT sequence, body_sequence, event_json, at FROM activity ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.limit);
-    }
-    return {
-        rows: rows.map(decodeActivityRow),
-        lowestRetained: bounds.lowest,
-        highest: bounds.highest,
-    };
-}
-export function deathExists(database) {
-    return database.prepare("SELECT kind FROM control WHERE kind = 'death'").get() !== undefined;
-}
-export function insertTellFact(database, tell) {
-    database.prepare(`INSERT INTO tells(id, body, state, recorded_at)
-    VALUES (?, ?, 'recorded', ?)`).run(tell.id, tell.body, tell.recordedAt);
-}
-export function tellState(database, id) {
-    const row = database.prepare("SELECT state FROM tells WHERE id = ?").get(id);
-    return row?.state ?? null;
-}
-export function updateTellState(database, id, state) {
-    database.prepare("UPDATE tells SET state = ? WHERE id = ?").run(state, id);
+    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 (?, ?, ?, ?)")
+        .run(sequence, input.turnSequence, encodeActivityEvent(input.event), input.at);
+    return sequence;
 }
 const REQUEST_COLUMNS = `sequence, id, archetype, body, cwd, world, recipe_json, admitted_at,
   state, child, diagnostic, evidence`;
@@ -224,54 +160,80 @@ export function updateRequestVoided(database, id, evidence) {
     database.prepare(`UPDATE requests SET state = 'voided', child = NULL, evidence = ?
     WHERE id = ? AND state IN ('admitted', 'reserved')`).run(evidence, id);
 }
-export function insertStopControl(database, at) {
-    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', '{}', ?)").run(at);
+export function insertStopControl(database, bodySequence, at) {
+    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
+        .run(json({ bodySequence }), at);
 }
 export function insertPauseControl(database, at) {
-    database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('pause', '{}', ?)").run(at);
-}
-export function stopExists(database) {
-    return database.prepare("SELECT kind FROM control WHERE kind = 'stop'").get() !== undefined;
-}
-export function pauseExists(database) {
-    return database.prepare("SELECT kind FROM control WHERE kind = 'pause'").get() !== undefined;
-}
-export function deleteAbandonedControls(database) {
-    database.prepare("DELETE FROM control WHERE kind IN ('stop', 'pause')").run();
-}
-export function insertDeathFact(database, death) {
-    database.prepare("INSERT INTO control(kind, value_json, at) VALUES ('death', ?, ?)")
-        .run(encodeDeathRow(death), death.at);
-}
-export function voidTellsByDeath(database) {
-    database.prepare("UPDATE tells SET state = 'voided-by-death' WHERE state NOT IN ('consumed', 'voided-by-death')").run();
+    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', ?, ?)")
+        .run(json({ bodySequence: body.sequence }), at);
+}
+export function stopFact(database) {
+    const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'stop'").get();
+    if (row === undefined)
+        return null;
+    const value = parsed(row.value_json);
+    if (!Number.isSafeInteger(value.bodySequence) || value.bodySequence <= 0) {
+        throw new Error("Akuma stop control has an invalid Body sequence");
+    }
+    return { bodySequence: value.bodySequence, requestedAt: row.at };
+}
+export function pauseFact(database) {
+    const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'pause'").get();
+    if (row === undefined)
+        return null;
+    const value = parsed(row.value_json);
+    if (!Number.isSafeInteger(value.bodySequence) || value.bodySequence <= 0) {
+        throw new Error("Akuma pause control has an invalid Body sequence");
+    }
+    return { bodySequence: value.bodySequence, requestedAt: row.at };
 }
-export function voidRequestsByDeath(database, evidence) {
-    database.prepare(`UPDATE requests SET state = 'voided',
-    evidence = CASE WHEN child IS NULL THEN ? ELSE ? || '; child=' || child END,
-    child = NULL
-    WHERE state IN ('admitted', 'reserved')`).run(evidence, evidence);
+export function insertKillFact(database, bodySequence, at) {
+    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")
         .run(input.end, input.at, input.sequence);
 }
-export function insertAnsweredTurnFact(database, input) {
-    const result = database.prepare(`INSERT INTO turns(body_sequence, outcome, history_id, session_json, answer, completed_at)
-    VALUES (?, 'answered', ?, ?, ?, ?)`).run(input.bodySequence, input.outcome.historyId, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.completedAt);
-    return Number(result.lastInsertRowid);
-}
-export function insertFailedTurnFact(database, input) {
-    const result = database.prepare(`INSERT INTO turns(body_sequence, outcome, diagnostic, completed_at)
-    VALUES (?, 'failed', ?, ?)`).run(input.bodySequence, input.outcome.diagnostic, input.completedAt);
-    return Number(result.lastInsertRowid);
+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`)
+        .run(input.diagnostic, input.at, input.sequence);
+    if (result.changes !== 1)
+        throw new Error(`Akuma Body ${input.sequence} cannot record hung custody`);
+}
+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 (?, ?, ?)")
+        .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 (?, ?, ?, ?)")
+            .run(callSequence, sequence, input.call, input.startedAt);
+    }
+    return { kind: "turn-start", sequence, bodySequence: input.bodySequence, startedAt: input.startedAt };
+}
+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);
+    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")
         .run(input.at, input.sequence);
 }
 export function latestBodyFact(database) {
-    const row = database.prepare(`SELECT sequence, pid, process_group, spawned_at, leash_taken_at, end, ended_at
+    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);
 }
@@ -286,34 +248,34 @@ export function sessionFactForCoordinate(database, coordinate) {
         .get(encodeResumeCoordinate(coordinate));
     return row === undefined ? null : decodeSessionRow(row);
 }
-export function pendingTellFacts(database) {
-    const rows = database.prepare(`SELECT id, body, state, recorded_at FROM tells
-    WHERE state NOT IN ('consumed', 'voided-by-death') ORDER BY recorded_at, id`)
-        .all();
-    return rows.map(decodeTellRow);
-}
-export function deathFact(database) {
-    const row = database.prepare("SELECT value_json, at FROM control WHERE kind = 'death'").get();
-    return row === undefined ? null : decodeDeathRow(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,
+    };
 }
-export function historyFacts(database) {
-    const rows = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
-    answer, diagnostic, completed_at FROM turns ORDER BY sequence`).all();
-    return rows.map(decodeTurnRow);
+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,
+    };
 }
 export function lastAnsweredTurnFact(database) {
-    const row = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
-    answer, diagnostic, completed_at FROM turns WHERE outcome = 'answered' ORDER BY sequence DESC LIMIT 1`)
+    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 latestTurnFact(database) {
-    const row = database.prepare(`SELECT sequence, body_sequence, outcome, history_id, session_json,
-    answer, diagnostic, completed_at FROM turns ORDER BY sequence DESC LIMIT 1`).get();
-    return row === undefined ? null : decodeTurnRow(row);
-}
 export function answeredTurnFact(database, historyId) {
-    const row = database.prepare(`SELECT sequence, body_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/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 = 6)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 6);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    description TEXT,\n    provider_json TEXT NOT NULL CHECK (json_valid(provider_json)),\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    cwd TEXT NOT NULL,\n    origin_json TEXT NOT NULL CHECK (json_valid(origin_json)),\n    confinement_json TEXT NOT NULL CHECK (json_valid(confinement_json)),\n    created_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    pid INTEGER NOT NULL CHECK (pid > 0),\n    process_group INTEGER NOT NULL CHECK (process_group > 0),\n    spawned_at TEXT NOT NULL,\n    leash_taken_at TEXT NOT NULL,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT\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 AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    outcome TEXT NOT NULL 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 NOT NULL,\n    CHECK (\n      (outcome = 'answered' AND history_id IS NOT NULL 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    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\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    body TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('recorded', 'delivered', 'seen', 'consumed', 'voided-by-death')),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child 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', 'death')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\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 = 14)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 14);\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    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child 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";