@astrosheep/keiyaku 4.5.11 → 4.5.13

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;
@@ -146,6 +164,8 @@ export type RequestFact = (AdmittedRequest & Readonly<{
 }>) | (AdmittedRequest & Readonly<{
     state: "reserved";
     child: AkuId;
+}>) | (AdmittedRequest & Readonly<{
+    state: "begun";
 }>) | (AdmittedRequest & Readonly<{
     state: "served";
     child: AkuId;
@@ -155,6 +175,9 @@ export type RequestFact = (AdmittedRequest & Readonly<{
 }>) | (AdmittedRequest & Readonly<{
     state: "refused";
     diagnostic: string;
+}>) | (AdmittedRequest & Readonly<{
+    state: "unproven";
+    evidence: string;
 }>) | (AdmittedRequest & Readonly<{
     state: "voided";
     evidence: string;

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

@@ -4,9 +4,10 @@ export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
-export { admitRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, 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 { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.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";
@@ -30,6 +33,30 @@ export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequ
 export declare function readTell(paths: AkumaPaths, id: string): Promise<TellFact | null>;
 export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
 export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
+export type PendingTellDisposition = Readonly<{
+    bodySequence: number;
+    tellIds: readonly string[];
+}>;
+export declare function decidePendingTellDisposition(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    at: string;
+    handoff: boolean;
+}>): Promise<PendingTellDisposition | null>;
+export declare function readOpenPendingTellDisposition(paths: AkumaPaths): Promise<PendingTellDisposition | null>;
+export declare function resolvePendingTellDisposition(paths: AkumaPaths, bodySequence: number, at: string): Promise<void>;
+/**
+ * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
+ * an unqualified held leash are never proof. Returns the successor Body sequence
+ * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
+ * the snapshot is already fully settled (no longer pending).
+ */
+export declare function provePendingTellDispositionCustody(paths: AkumaPaths, disposition: PendingTellDisposition): Promise<Readonly<{
+    kind: "proven";
+    successorBodySequence?: number;
+} | {
+    kind: "unproven";
+}>>;
+export declare function recordUndeliveredPendingTells(paths: AkumaPaths, at: string, tellIds: readonly string[]): Promise<void>;
 export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
 export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
     kind: "requested";
@@ -55,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, insertTellFact, insertTellReceiptFact, pendingTellFacts, 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, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
-export { life, lifeAt, projectTell } from "./facts.js";
+export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.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: [] } };
@@ -91,6 +99,64 @@ export async function recordTellReceipt(paths, input) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
     }));
 }
+export async function decidePendingTellDisposition(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const body = latestBodyFact(heart);
+        if (body === null || body.sequence !== input.bodySequence)
+            return null;
+        const existing = openTellDispositionIds(heart, input.bodySequence);
+        if (existing !== null)
+            return { bodySequence: input.bodySequence, tellIds: existing };
+        const pending = pendingTellFacts(heart);
+        const tellIds = pending.map((tell) => tell.id);
+        if (tellIds.length === 0)
+            return null;
+        if (body.end === undefined) {
+            if (!input.handoff)
+                return null;
+            endBodyFact(heart, { sequence: input.bodySequence, end: "put-down", at: input.at });
+        }
+        else if (body.end === "broke-off") {
+            return null;
+        }
+        insertTellDispositionSnapshot(heart, input.bodySequence, tellIds, input.at);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+        return { bodySequence: input.bodySequence, tellIds };
+    }));
+}
+export async function readOpenPendingTellDisposition(paths) {
+    return await withHeart(paths, (heart) => readTransaction(heart, () => latestOpenTellDisposition(heart)));
+}
+export async function resolvePendingTellDisposition(paths, bodySequence, at) {
+    await withHeart(paths, (heart) => transaction(heart, () => {
+        resolveTellDispositionSnapshot(heart, bodySequence, at);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
+/**
+ * Heart-owned disposition custody proof. Sequence growth, spawn resolution, and
+ * an unqualified held leash are never proof. Returns the successor Body sequence
+ * when that exact Body took the frozen Tell-id snapshot by delivery, or true when
+ * the snapshot is already fully settled (no longer pending).
+ */
+export async function provePendingTellDispositionCustody(paths, disposition) {
+    return await withHeart(paths, (heart) => readTransaction(heart, () => {
+        if (!dispositionSnapshotProven(heart, disposition))
+            return { kind: "unproven" };
+        const successorBodySequence = successorBodyHoldingDisposition(heart, disposition);
+        return successorBodySequence === null
+            ? { kind: "proven" }
+            : { kind: "proven", successorBodySequence };
+    }));
+}
+export async function recordUndeliveredPendingTells(paths, at, tellIds) {
+    if (tellIds.length === 0)
+        return;
+    await withHeart(paths, (heart) => transaction(heart, () => {
+        insertUndeliveredTellReceipts(heart, tellIds, at);
+        pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    }));
+}
 export async function readKill(paths, bodySequence) {
     return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
@@ -144,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/request-authority.d.ts

@@ -10,5 +10,7 @@ export declare function serveRequest(paths: AkumaPaths, id: string, child: strin
 export declare function serveUpstreamRequest(paths: AkumaPaths, id: string, serviceJson: string): Promise<RequestFact>;
 export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
 export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
+export declare function beginRequest(paths: AkumaPaths, id: string): Promise<RequestFact>;
+export declare function unproveRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
 export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
 export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;

package/build/src/akuma/heart/request-authority.js

@@ -1,5 +1,5 @@
 import { parseAkuId } from "../identity.js";
-import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
+import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestBegun, updateRequestReserved, updateRequestServed, updateRequestUnproven, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
 import { transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { requestPayloadJson } from "./request-rows.js";
@@ -72,7 +72,7 @@ export async function serveUpstreamRequest(paths, id, serviceJson) {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted")
+        if (before.state === "begun")
             updateUpstreamRequestServed(heart, id, serviceJson);
         else if (before.state !== "served" || !("serviceJson" in before) || before.serviceJson !== serviceJson) {
             throw new Error(`Akuma request ${id} cannot be served with this service reference`);
@@ -98,7 +98,7 @@ export async function voidRequest(paths, id, evidence) {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
-        if (before.state === "admitted" || before.state === "reserved") {
+        if (before.state === "admitted" || before.state === "reserved" || before.state === "begun") {
             updateRequestVoided(heart, id, evidence);
         }
         else if (before.state !== "voided" || before.evidence !== evidence) {
@@ -107,6 +107,31 @@ export async function voidRequest(paths, id, evidence) {
         return requestFact(heart, id);
     }));
 }
+export async function beginRequest(paths, id) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "admitted")
+            updateRequestBegun(heart, id);
+        else if (before.state !== "begun")
+            throw new Error(`Akuma request ${id} cannot begin`);
+        return requestFact(heart, id);
+    }));
+}
+export async function unproveRequest(paths, id, evidence) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.state === "begun")
+            updateRequestUnproven(heart, id, evidence);
+        else if (before.state !== "unproven" || before.evidence !== evidence) {
+            throw new Error(`Akuma request ${id} cannot be marked unproven`);
+        }
+        return requestFact(heart, id);
+    }));
+}
 export async function readRequest(paths, id) {
     return await withHeart(paths, (heart) => requestFact(heart, id));
 }

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

@@ -11,6 +11,8 @@ export declare function requestFact(database: DatabaseSync, id: string): Request
 export declare function nonterminalRequestFacts(database: DatabaseSync): readonly RequestFact[];
 export declare function updateRequestReserved(database: DatabaseSync, id: string, child: AkuId): void;
 export declare function updateRequestServed(database: DatabaseSync, id: string, child: AkuId): void;
+export declare function updateRequestBegun(database: DatabaseSync, id: string): void;
 export declare function updateUpstreamRequestServed(database: DatabaseSync, id: string, service: unknown): 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 updateRequestUnproven(database: DatabaseSync, id: string, evidence: string): void;

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

@@ -21,6 +21,12 @@ function decodeRequestRow(row) {
         }
         return { ...input, state: row.state, child: row.child };
     }
+    if (row.state === "begun") {
+        if (row.child !== null || row.service_json !== null || row.diagnostic !== null || row.evidence !== null) {
+            throw new Error("Akuma authority contains an invalid begun request");
+        }
+        return { ...input, state: row.state };
+    }
     if (row.state === "served") {
         if (row.child !== null && row.service_json === null) {
             return { ...input, state: row.state, child: row.child };
@@ -30,11 +36,15 @@ function decodeRequestRow(row) {
         }
         throw new Error("Akuma authority contains an invalid served request");
     }
+    if (row.state === "admitted")
+        return { ...input, state: row.state };
     if (row.state === "refused")
         return { ...input, state: row.state, diagnostic: row.diagnostic };
+    if (row.state === "unproven")
+        return { ...input, state: row.state, evidence: row.evidence };
     if (row.state === "voided")
         return { ...input, state: row.state, evidence: row.evidence };
-    return { ...input, state: "admitted" };
+    throw new Error(`Akuma authority contains an unknown request state: ${row.state}`);
 }
 const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted_at,
   state, child, service_json, diagnostic, evidence`;
@@ -53,7 +63,7 @@ export function requestFact(database, id) {
 export function nonterminalRequestFacts(database) {
     const rows = database
         .prepare(`SELECT ${REQUEST_COLUMNS} FROM requests
-    WHERE state IN ('admitted', 'reserved') ORDER BY sequence`)
+    WHERE state IN ('admitted', 'reserved', 'begun') ORDER BY sequence`)
         .all();
     return rows.map(decodeRequestRow);
 }
@@ -68,10 +78,13 @@ export function updateRequestServed(database, id, child) {
     WHERE id = ? AND state = 'reserved'`)
         .run(child, id);
 }
+export function updateRequestBegun(database, id) {
+    database.prepare("UPDATE requests SET state = 'begun' WHERE id = ? AND state = 'admitted'").run(id);
+}
 export function updateUpstreamRequestServed(database, id, service) {
     database
         .prepare(`UPDATE requests SET state = 'served', service_json = ?
-    WHERE id = ? AND state = 'admitted'`)
+    WHERE id = ? AND state = 'begun'`)
         .run(assertJsonText(service), id);
 }
 export function updateRequestRefused(database, id, diagnostic) {
@@ -82,7 +95,13 @@ export function updateRequestRefused(database, id, diagnostic) {
 }
 export function updateRequestVoided(database, id, evidence) {
     database
-        .prepare(`UPDATE requests SET state = 'voided', child = NULL, service_json = NULL, evidence = ?
-    WHERE id = ? AND state IN ('admitted', 'reserved')`)
+        .prepare(`UPDATE requests SET state = 'voided', child = NULL, service_json = NULL, diagnostic = NULL, evidence = ?
+    WHERE id = ? AND state IN ('admitted', 'reserved', 'begun')`)
+        .run(evidence, id);
+}
+export function updateRequestUnproven(database, id, evidence) {
+    database
+        .prepare(`UPDATE requests SET state = 'unproven', child = NULL, service_json = NULL, diagnostic = NULL, evidence = ?
+    WHERE id = ? AND state = 'begun'`)
         .run(evidence, id);
 }

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 = 21)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 21);\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,\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 child IS NOT NULL AND service_json IS NULL\n        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    )\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";