@astrosheep/keiyaku 4.5.12 → 4.5.13

package/build/src/akuma/akuma-errors.d.ts

@@ -1,4 +1,5 @@
 import type { AkuId } from "./identity.js";
+export { AkumaBusyError } from "./heart/facts.js";
 export declare class AkumaNotBornError extends Error {
     readonly id: AkuId;
     readonly kind = "akuma-not-born";

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

@@ -1,3 +1,4 @@
+export { AkumaBusyError } from "./heart/facts.js";
 export class AkumaNotBornError extends Error {
     id;
     kind = "akuma-not-born";

package/build/src/akuma/body.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, provePendingTellDispositionCustody, readHeart, readOpenPendingTellDisposition, readTell, readNonterminalRequests, recordUndeliveredPendingTells, resolvePendingTellDisposition, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, provePendingTellDispositionCustody, readHeart, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, recordUndeliveredPendingTells, resolvePendingTellDisposition, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { pluginRuntime } from "../plugin/runtime.js";
 import { World } from "../world.js";
@@ -17,8 +17,14 @@ export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
+async function failOpenBoundTurnsIfPresent(paths, bodySequence, diagnostic, at) {
+    if (!(await heartExists(paths)))
+        return;
+    await failOpenBoundTurns(paths, { bodySequence, diagnostic, completedAt: at });
+}
 async function putDownIfControlled(paths, supervisor, bodySequence, now) {
     if (supervisor.reason === "control" && (await heartExists(paths))) {
+        await failOpenBoundTurnsIfPresent(paths, bodySequence, "Body put-down with open bound Turns", now());
         await breakBody(paths, { sequence: bodySequence, end: "put-down", at: now() });
     }
 }
@@ -62,8 +68,48 @@ async function launchCwd(launch) {
         throw new Error("Akuma wake has no born soul");
     return (await turnRecipe(launch.paths, soul)).cwd;
 }
+function parseSchemaAnswerJson(raw) {
+    try {
+        JSON.parse(raw);
+        return { kind: "json", json: raw };
+    }
+    catch (error) {
+        return {
+            kind: "invalid",
+            diagnostic: error instanceof Error ? error.message : "Answer is not valid JSON",
+        };
+    }
+}
 async function persistTurn(paths, turnSequence, result, completedAt) {
+    const turn = await readTurn(paths, turnSequence);
+    const schemaJson = turn?.schemaJson;
     if (result.kind === "answered" && result.session !== undefined) {
+        if (schemaJson !== undefined) {
+            const parsed = parseSchemaAnswerJson(result.answer);
+            if (parsed.kind === "invalid") {
+                const outcome = {
+                    kind: "invalid-output",
+                    diagnostic: parsed.diagnostic,
+                    answer: result.answer,
+                    session: result.session,
+                    ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
+                };
+                await endTurn(paths, { turnSequence, outcome, completedAt });
+                return { outcome: "failed", diagnostic: parsed.diagnostic };
+            }
+            await endTurn(paths, {
+                turnSequence,
+                outcome: {
+                    kind: "answered",
+                    session: result.session,
+                    answer: result.answer,
+                    answerJson: parsed.json,
+                    ...(result.historyId === undefined ? {} : { historyId: result.historyId }),
+                },
+                completedAt,
+            });
+            return { outcome: "answered", answer: result.answer };
+        }
         await endTurn(paths, {
             turnSequence,
             outcome: {
@@ -178,7 +224,7 @@ async function runBodyTurns(input) {
     let initial = launch.initialBody;
     const emitTurnOutcome = turnOutcomeEmitter(launch, soul);
     for (;;) {
-        const launchTells = supervisor.current().pending;
+        const launchTells = drainPendingTells(supervisor.current().pending);
         if (supervisor.signal.aborted) {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -203,12 +249,17 @@ async function runBodyTurns(input) {
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             launchTells,
+            ...(launchTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson === undefined
+                ? {}
+                : { schemaJson: launchTells.find((tell) => tell.schemaJson !== undefined).schemaJson }),
             world: runtime.world,
             externalCommands: runtime.externalCommands,
             now: runtime.now,
         });
-        if (result.kind === "hung")
+        if (result.kind === "hung") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, "Body hung with open bound Turns", runtime.now());
             return;
+        }
         if (result.kind === "stopped") {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -216,12 +267,14 @@ async function runBodyTurns(input) {
         if (result.kind === "handoff")
             return "handoff";
         if (result.kind === "resume-unsupported") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, "resume-unsupported with open bound Turns", runtime.now());
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }
         const outcome = await persistTurn(launch.paths, result.turnSequence, result, runtime.now());
         emitTurnOutcome(result.turnSequence, outcome);
         if (outcome.outcome === "failed") {
+            await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, outcome.diagnostic, runtime.now());
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
             return;
         }
@@ -378,6 +431,15 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     }
     finally {
         if (bodySequence !== undefined && (await heartExists(launch.paths))) {
+            const body = (await readHeart(launch.paths)).latestBody;
+            const inert = body?.sequence === bodySequence && (body.end !== undefined || body.hung !== undefined);
+            if (inert) {
+                await failOpenBoundTurns(launch.paths, {
+                    bodySequence,
+                    diagnostic: body.hung?.diagnostic ?? `Body ${body.end ?? "ended"} with open bound Turns`,
+                    completedAt: runtime.now(),
+                });
+            }
             decidedDisposition = await decidePendingTellDisposition(launch.paths, {
                 bodySequence,
                 at: runtime.now(),

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

@@ -58,15 +58,23 @@ export type TurnOutcome = Readonly<{
     historyId?: string;
     session: ResumeCoordinate;
     answer: string;
+    answerJson?: string;
 }> | Readonly<{
     kind: "failed";
     diagnostic: string;
+}> | Readonly<{
+    kind: "invalid-output";
+    diagnostic: string;
+    answer: string;
+    historyId?: string;
+    session?: ResumeCoordinate;
 }>;
 export type TurnStartFact = Readonly<{
     kind: "turn-start";
     sequence: number;
     bodySequence: number;
     startedAt: string;
+    schemaJson?: string;
 }>;
 export type TurnEndFact = Readonly<{
     kind: "turn-end";
@@ -91,14 +99,20 @@ export type TellDelivery = Readonly<{
     receipt?: "unavailable" | "required";
     deliveredAt: string;
 }>;
+export type TellBinding = Readonly<{
+    turnSequence: number;
+    boundAt: string;
+}>;
 export type TellFact = Readonly<{
     kind: "tell";
     sequence: number;
     id: string;
     body: string;
+    schemaJson?: string;
     recordedAt: string;
     state: "pending" | "told";
     deliveries: readonly TellDelivery[];
+    binding?: TellBinding;
 }>;
 export type TellRow = Readonly<{
     kind: "tell";
@@ -110,6 +124,10 @@ export type TellRow = Readonly<{
     deliveries: readonly TellDelivery[];
 }>;
 export declare function projectTell(fact: TellFact): TellRow;
+export declare class AkumaBusyError extends Error {
+    readonly kind = "akuma-busy";
+    constructor();
+}
 export type TellDeliveryInput = Readonly<{
     tellId: string;
     turnSequence: number;

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

@@ -9,6 +9,13 @@ export function projectTell(fact) {
         deliveries: fact.deliveries,
     };
 }
+export class AkumaBusyError extends Error {
+    kind = "akuma-busy";
+    constructor() {
+        super("Akuma is busy");
+        this.name = "AkumaBusyError";
+    }
+}
 export function life(input) {
     if (input.body?.hung !== undefined)
         return "hung";

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

@@ -5,8 +5,9 @@ import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
-export { life, lifeAt, projectTell } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellRow, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
+export { drainPendingTells } from "./tells.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellBinding, TellFact, TellRow, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
@@ -21,7 +22,9 @@ export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
-export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
+export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
+    interrupt?: boolean;
+}>): Promise<Readonly<{
     kind: "not-born";
 } | {
     kind: "recorded";
@@ -79,7 +82,19 @@ export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
     bodySequence: number;
     startedAt: string;
     call?: string;
+    schemaJson?: string;
 }>): Promise<TurnStartFact>;
+export declare function bindTellsToTurn(paths: AkumaPaths, input: Readonly<{
+    turnSequence: number;
+    tellIds: readonly string[];
+    boundAt: string;
+}>): Promise<void>;
+export declare function failOpenBoundTurns(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    diagnostic: string;
+    completedAt: string;
+}>): Promise<readonly number[]>;
+export declare function readTurn(paths: AkumaPaths, sequence: number): Promise<TurnFact | null>;
 export declare function endTurn(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;
     outcome: TurnOutcome;

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

@@ -1,12 +1,14 @@
 import { parsePublicHistoryId } from "../identity.js";
-import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
-import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openTellDispositionIds, pendingTellFacts, resolveTellDispositionSnapshot, successorBodyHoldingDisposition, tellFact, tellIdsForFence, } from "./tells.js";
+import { answeredTurnFact, decodeTurnRow, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, } from "./rows.js";
+import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, resolveTellDispositionSnapshot, successorBodyHoldingDisposition, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart, withReadOnlyHeart, } from "./storage.js";
 import { soulFact } from "./soul.js";
+import { AkumaBusyError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
-export { life, lifeAt, projectTell } from "./facts.js";
+export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
+export { drainPendingTells } from "./tells.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {
     try {
@@ -51,17 +53,23 @@ export async function appendActivity(paths, input) {
 export async function activitySlice(paths) {
     return await withHeart(paths, (heart) => readTransaction(heart, () => activityFactSlice(heart)));
 }
-export async function recordTell(paths, tell) {
+function sameTellInput(existing, tell) {
+    return existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson;
+}
+export async function recordTell(paths, tell, options = {}) {
     return await withHeart(paths, (heart) => transaction(heart, () => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const existing = tellFact(heart, tell.id);
         if (existing !== null) {
-            if (existing.body !== tell.body || existing.recordedAt !== tell.recordedAt) {
+            if (!sameTellInput(existing, tell))
                 throw new Error(`tell ${tell.id} reused different input`);
-            }
             return { kind: "recorded", tell: existing };
         }
+        const body = latestBodyFact(heart);
+        const running = body !== null && body.end === undefined && body.hung === undefined;
+        if (tell.schemaJson !== undefined && running && options.interrupt !== true)
+            throw new AkumaBusyError();
         const sequence = insertTellFact(heart, tell);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
@@ -202,6 +210,40 @@ export async function beginTurn(paths, input) {
         return fact;
     }));
 }
+export async function bindTellsToTurn(paths, input) {
+    await withHeart(paths, (heart) => transaction(heart, () => {
+        for (const tellId of input.tellIds) {
+            if (tellFact(heart, tellId) === null)
+                throw new Error(`unknown tell ${tellId}`);
+            insertTellBindingFact(heart, { tellId, turnSequence: input.turnSequence, boundAt: input.boundAt });
+        }
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
+export async function failOpenBoundTurns(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const sequences = openBoundTurns(heart, input.bodySequence);
+        for (const turnSequence of sequences) {
+            insertTurnEndFact(heart, {
+                kind: "turn-end",
+                turnSequence,
+                outcome: { kind: "failed", diagnostic: input.diagnostic },
+                completedAt: input.completedAt,
+            });
+        }
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return sequences;
+    }));
+}
+export async function readTurn(paths, sequence) {
+    return await withHeart(paths, (heart) => readTransaction(heart, () => {
+        const row = heart
+            .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
+        session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE sequence = ?`)
+            .get(sequence);
+        return row === undefined ? null : decodeTurnRow(row);
+    }));
+}
 export async function endTurn(paths, input) {
     return await withHeart(paths, (heart) => transaction(heart, () => {
         const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });

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

@@ -25,10 +25,12 @@ export type TurnRow = Readonly<{
     body_sequence: number;
     started_at: string;
     end_sequence: number | null;
-    outcome: "answered" | "failed" | null;
+    outcome: "answered" | "failed" | "invalid-output" | null;
     history_id: string | null;
     session_json: string | null;
     answer: string | null;
+    answer_json: string | null;
+    schema_json: string | null;
     diagnostic: string | null;
     completed_at: string | null;
 }>;
@@ -104,6 +106,7 @@ export declare function insertTurnStartFact(database: DatabaseSync, input: Reado
     bodySequence: number;
     startedAt: string;
     call?: string;
+    schemaJson?: string;
 }>): TurnStartFact;
 export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
 export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{

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

@@ -44,12 +44,34 @@ export function decodeBodyRow(row) {
         ...(row.ended_at === null ? {} : { endedAt: row.ended_at }),
     };
 }
+function decodeTurnOutcome(row) {
+    if (row.outcome === "answered") {
+        return {
+            kind: "answered",
+            ...(row.history_id === null ? {} : { historyId: row.history_id }),
+            session: resumeCoordinate(parsed(row.session_json)),
+            answer: row.answer,
+            ...(row.answer_json === null ? {} : { answerJson: row.answer_json }),
+        };
+    }
+    if (row.outcome === "invalid-output") {
+        return {
+            kind: "invalid-output",
+            diagnostic: row.diagnostic,
+            answer: row.answer,
+            ...(row.history_id === null ? {} : { historyId: row.history_id }),
+            ...(row.session_json === null ? {} : { session: resumeCoordinate(parsed(row.session_json)) }),
+        };
+    }
+    return { kind: "failed", diagnostic: row.diagnostic };
+}
 export function decodeTurnRow(row) {
     const start = {
         kind: "turn-start",
         sequence: row.sequence,
         bodySequence: row.body_sequence,
         startedAt: row.started_at,
+        ...(row.schema_json === null || row.schema_json === undefined ? {} : { schemaJson: row.schema_json }),
     };
     if (row.outcome === null)
         return start;
@@ -57,14 +79,7 @@ export function decodeTurnRow(row) {
         kind: "turn-end",
         sequence: row.end_sequence,
         turnSequence: row.sequence,
-        outcome: row.outcome === "answered"
-            ? {
-                kind: "answered",
-                ...(row.history_id === null ? {} : { historyId: row.history_id }),
-                session: resumeCoordinate(parsed(row.session_json)),
-                answer: row.answer,
-            }
-            : { kind: "failed", diagnostic: row.diagnostic },
+        outcome: decodeTurnOutcome(row),
         completedAt: row.completed_at,
     };
     return { ...start, end };
@@ -177,27 +192,39 @@ 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 (?, ?, ?)")
-        .run(sequence, input.bodySequence, input.startedAt);
+        .prepare("INSERT INTO turns(sequence, body_sequence, started_at, schema_json) VALUES (?, ?, ?, ?)")
+        .run(sequence, input.bodySequence, input.startedAt, input.schemaJson ?? null);
     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 };
+    return {
+        kind: "turn-start",
+        sequence,
+        bodySequence: input.bodySequence,
+        startedAt: input.startedAt,
+        ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
+    };
 }
 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);
+        session_json = ?, answer = ?, answer_json = ?, completed_at = ? WHERE sequence = ? AND end_sequence IS NULL`)
+            .run(sequence, input.outcome.historyId ?? null, encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.outcome.answerJson ?? null, input.completedAt, input.turnSequence)
+        : input.outcome.kind === "invalid-output"
+            ? database
+                .prepare(`UPDATE turns SET end_sequence = ?, outcome = 'invalid-output', history_id = ?,
+          session_json = ?, answer = ?, diagnostic = ?, completed_at = ?
+          WHERE sequence = ? AND end_sequence IS NULL`)
+                .run(sequence, input.outcome.historyId ?? null, input.outcome.session === undefined ? null : encodeResumeCoordinate(input.outcome.session), input.outcome.answer, input.outcome.diagnostic, 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 };
@@ -259,14 +286,14 @@ export function killFactForBody(database, bodySequence) {
 export function lastAnsweredTurnFact(database) {
     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`)
+    session_json, answer, answer_json, schema_json, 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, turnSequence) {
     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 sequence = ?`)
+    session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND sequence = ?`)
         .get(turnSequence);
     return row === undefined ? null : decodeTurnRow(row);
 }

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

@@ -2,5 +2,5 @@ import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
 export declare function heartSchemaIsCurrent(database: DatabaseSync): boolean;
-export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 23)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 23);\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 tell_dispositions (\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT,\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\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,\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', 'begun', 'served', 'refused', 'voided', 'unproven')),\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 child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (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      OR (state = 'unproven' 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 = 24)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 24);\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', 'invalid-output')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\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        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL\n        AND answer_json IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL\n        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL\n        AND answer IS NULL AND answer_json 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    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_bindings (\n    tell_id TEXT PRIMARY KEY REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    bound_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 tell_dispositions (\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT,\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\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,\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', 'begun', 'served', 'refused', 'voided', 'unproven')),\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 child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (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      OR (state = 'unproven' 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 = 23;
+const HEART_SCHEMA_VERSION = 24;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -53,16 +53,23 @@ export const HEART_SCHEMA = `
     body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
     started_at TEXT NOT NULL,
     end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,
-    outcome TEXT CHECK (outcome IN ('answered', 'failed')),
+    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),
     history_id TEXT UNIQUE,
     session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),
     answer TEXT,
+    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),
+    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),
     diagnostic TEXT,
     completed_at TEXT,
     CHECK (
-      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)
-      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)
-      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)
+      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL
+        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))
+      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL
+        AND answer_json IS NULL AND diagnostic IS NOT NULL)
+      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL
+        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)
+      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL
+        AND answer IS NULL AND answer_json IS NULL AND diagnostic IS NULL AND completed_at IS NULL)
     )
   ) STRICT;
   CREATE TABLE IF NOT EXISTS timeline (
@@ -85,8 +92,14 @@ export const HEART_SCHEMA = `
     id TEXT PRIMARY KEY,
     sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,
     body TEXT NOT NULL,
+    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),
     recorded_at TEXT NOT NULL
   ) STRICT;
+  CREATE TABLE IF NOT EXISTS tell_bindings (
+    tell_id TEXT PRIMARY KEY REFERENCES tells(id) ON DELETE CASCADE,
+    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,
+    bound_at TEXT NOT NULL
+  ) STRICT;
   CREATE TABLE IF NOT EXISTS tell_deliveries (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,

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

@@ -39,7 +39,7 @@ export declare class HeldAkumaLeash {
         target: StopFact;
         result: "recorded" | "already-killed";
     }> | null>;
-    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
+    recordInterruptTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Promise<Readonly<{
         kind: "not-born";
     } | {
         kind: "recorded";

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

@@ -32,3 +32,10 @@ export declare function successorBodyHoldingDisposition(database: DatabaseSync,
     tellIds: readonly string[];
 }>): number | null;
 export declare function insertUndeliveredTellReceipts(database: DatabaseSync, tellIds: readonly string[], at: string): void;
+export declare function insertTellBindingFact(database: DatabaseSync, input: Readonly<{
+    tellId: string;
+    turnSequence: number;
+    boundAt: string;
+}>): void;
+export declare function drainPendingTells(pending: readonly TellFact[]): readonly TellFact[];
+export declare function openBoundTurns(database: DatabaseSync, bodySequence: number): readonly number[];