@astrosheep/keiyaku 4.6.19 → 4.6.21

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { providerOptionsSchema, withoutModel } from "../provider-recipe.js";
 import { resumeCoordinateSchema } from "../coordinate.js";
-import { HeartAuthorityCorruptionError } from "./facts.js";
+import { HeartAuthorityCorruptionError, reportFactSchema } from "./facts.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
 import { agentEventSchema } from "./activity-schema.js";
 const sessionText = z.string().refine((value) => value.trim() !== "");
@@ -80,6 +80,8 @@ function decodeTurnOutcome(row) {
             ...(row.session_json === null ? {} : { session: resumeCoordinate(parsed(row.session_json)) }),
         };
     }
+    if (row.outcome === "canceled")
+        return { kind: "canceled" };
     return { kind: "failed", diagnostic: row.diagnostic };
 }
 export function decodeTurnRow(row) {
@@ -105,6 +107,16 @@ export function decodeTurnRow(row) {
 export function decodeCallRow(row) {
     return { kind: "call", sequence: row.sequence, turnSequence: row.turn_sequence, body: row.body, at: row.at };
 }
+export function decodeReportRow(row) {
+    return reportFactSchema.parse({
+        kind: "report",
+        sequence: row.sequence,
+        bodySequence: row.body_sequence,
+        turnSequence: row.turn_sequence,
+        text: row.text,
+        at: row.at,
+    });
+}
 export function encodeActivityEvent(event) {
     return json(agentEventSchema.parse(event));
 }
@@ -149,6 +161,14 @@ export function insertSessionFact(database, input) {
         .run(...encodeSessionRow(input));
     return Number(result.lastInsertRowid);
 }
+export function insertReportFact(database, input) {
+    const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('report')").run().lastInsertRowid);
+    const fact = reportFactSchema.parse({ kind: "report", sequence, ...input });
+    database
+        .prepare("INSERT INTO reports(sequence, body_sequence, turn_sequence, text, at) VALUES (?, ?, ?, ?, ?)")
+        .run(sequence, input.bodySequence, input.turnSequence, input.text, input.at);
+    return fact;
+}
 export function insertActivityFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('activity')").run().lastInsertRowid);
     database
@@ -231,6 +251,11 @@ export function pauseFact(database) {
         ...(value.frontierTellId === undefined ? {} : { frontierTellId: value.frontierTellId }),
     };
 }
+export function hasBodyHandoffControl(database, bodySequence) {
+    return (killFactForBody(database, bodySequence) !== null ||
+        stopFact(database)?.bodySequence === bodySequence ||
+        pauseFact(database)?.bodySequence === bodySequence);
+}
 export function bodyFact(database, sequence) {
     const row = database
         .prepare(`SELECT sequence, leash_taken_at, hung_diagnostic, hung_at, end, ended_at FROM bodies WHERE sequence = ?`)
@@ -287,6 +312,20 @@ export function insertTurnStartFact(database, input) {
         ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
     };
 }
+export function openTurnsForBody(database, bodySequence) {
+    return database
+        .prepare("SELECT sequence FROM turns WHERE body_sequence = ? AND end_sequence IS NULL ORDER BY sequence")
+        .all(bodySequence)
+        .map((row) => Number(row.sequence));
+}
+export function terminalTurnForTell(database, tellId) {
+    const row = database
+        .prepare(`SELECT t.sequence FROM tell_bindings b
+    JOIN turns t ON t.sequence = b.turn_sequence
+    WHERE b.tell_id = ? AND t.end_sequence IS NOT NULL ORDER BY b.sequence LIMIT 1`)
+        .get(tellId);
+    return row === undefined ? null : turnFact(database, Number(row.sequence));
+}
 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"
@@ -300,10 +339,15 @@ export function insertTurnEndFact(database, input) {
           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 = ?
+            : input.outcome.kind === "canceled"
+                ? database
+                    .prepare(`UPDATE turns SET end_sequence = ?, outcome = 'canceled', completed_at = ?
+                WHERE sequence = ? AND end_sequence IS NULL`)
+                    .run(sequence, 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);
+                    .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 };

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

@@ -1,6 +1,9 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
+export declare function heartSchemaVersion(database: DatabaseSync): number | undefined;
 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 = 29)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 29);\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    initiator TEXT,\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 activity_retention (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    checked_sequence INTEGER NOT NULL\n  ) STRICT;\n  INSERT OR IGNORE INTO activity_retention(singleton, checked_sequence) VALUES (1, 0);\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    initiator TEXT,\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    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL 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    UNIQUE (tell_id, turn_sequence)\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);\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind);\n  CREATE TABLE IF NOT EXISTS tell_dispositions (\n    body_sequence INTEGER PRIMARY KEY REFERENCES bodies(sequence),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_disposition_members (\n    body_sequence INTEGER NOT NULL REFERENCES tell_dispositions(body_sequence) ON DELETE CASCADE,\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\n  CREATE INDEX IF NOT EXISTS calls_by_turn ON calls(turn_sequence);\n  CREATE INDEX IF NOT EXISTS activity_by_turn ON activity(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_bindings_by_turn ON tell_bindings(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_deliveries_by_turn ON tell_deliveries(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_disposition_members_by_tell ON tell_disposition_members(tell_id);\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";
+/** Called only under the open boundary's write transaction, with foreign keys disabled. */
+export declare function upgradeHeartSchema(database: DatabaseSync): void;
+export declare const HEART_SCHEMA: string;
 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 = 29;
+const HEART_SCHEMA_VERSION = 31;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -11,50 +11,33 @@ export function assertHeartSchemaVersion(database) {
 export function assertLeashSchemaVersion(database) {
     assertSchemaVersion(database, "leash_schema", LEASH_SCHEMA_VERSION);
 }
+export function heartSchemaVersion(database) {
+    return database.prepare("SELECT version FROM akuma_schema WHERE singleton = 1").get()?.version;
+}
 export function heartSchemaIsCurrent(database) {
     try {
-        const row = database.prepare(`SELECT version FROM akuma_schema WHERE singleton = 1`).get();
-        return row?.version === HEART_SCHEMA_VERSION;
+        return heartSchemaVersion(database) === HEART_SCHEMA_VERSION;
     }
     catch {
         return false;
     }
 }
-export const HEART_SCHEMA = `
+const VERSION_SCHEMA = `
   CREATE TABLE IF NOT EXISTS akuma_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
     version INTEGER NOT NULL CHECK (version = ${HEART_SCHEMA_VERSION})
   ) STRICT;
   INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, ${HEART_SCHEMA_VERSION});
-  CREATE TABLE IF NOT EXISTS soul (
-    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
-    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))
-  ) STRICT;
-  CREATE TABLE IF NOT EXISTS bodies (
-    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-    leash_taken_at TEXT NOT NULL,
-    hung_diagnostic TEXT,
-    hung_at TEXT,
-    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),
-    ended_at TEXT,
-    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)
-      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))
-  ) STRICT;
-  CREATE TABLE IF NOT EXISTS sessions (
-    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-    provider TEXT NOT NULL,
-    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),
-    cwd TEXT NOT NULL,
-    options_json TEXT NOT NULL CHECK (json_valid(options_json)),
-    admitted_at TEXT NOT NULL
-  ) STRICT;
-  CREATE TABLE IF NOT EXISTS turns (
+`;
+function turnSchema(table) {
+    return `
+  CREATE TABLE ${table === "turns" ? "IF NOT EXISTS " : ""}${table} (
     sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,
     body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
     started_at TEXT NOT NULL,
     initiator TEXT,
     end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,
-    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),
+    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output', 'canceled')),
     history_id TEXT UNIQUE,
     session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),
     answer TEXT,
@@ -69,14 +52,88 @@ export const HEART_SCHEMA = `
         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 = 'canceled' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL
+        AND answer_json IS NULL AND diagnostic IS 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;`;
+}
+/** Called only under the open boundary's write transaction, with foreign keys disabled. */
+export function upgradeHeartSchema(database) {
+    const version = heartSchemaVersion(database);
+    // Another opener may have completed the fixed conversion while this one waited.
+    if (version !== 29 && version !== 30) {
+        assertHeartSchemaVersion(database);
+        return;
+    }
+    if (version === 29) {
+        database.exec(turnSchema("turns_upgrade"));
+        database.exec(`
+      INSERT INTO turns_upgrade (sequence, body_sequence, started_at, initiator, end_sequence,
+        outcome, history_id, session_json, answer, answer_json, schema_json, diagnostic, completed_at)
+      SELECT sequence, body_sequence, started_at, initiator, end_sequence,
+        outcome, history_id, session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns;
+      DROP TABLE turns;
+      ALTER TABLE turns_upgrade RENAME TO turns;
+    `);
+    }
+    const highWater = database.prepare("SELECT seq FROM sqlite_sequence WHERE name = 'timeline'").get();
+    database.exec(timelineSchema("timeline_upgrade"));
+    database.exec(`
+    INSERT INTO timeline_upgrade SELECT sequence, kind FROM timeline;
+    DROP TABLE timeline;
+    ALTER TABLE timeline_upgrade RENAME TO timeline;
+    ${REPORT_SCHEMA}
+    DROP TABLE akuma_schema;
+    ${VERSION_SCHEMA}
+  `);
+    if (highWater !== undefined)
+        database.prepare("UPDATE sqlite_sequence SET seq = MAX(seq, ?) WHERE name = 'timeline'").run(highWater.seq);
+    if (database.prepare("PRAGMA foreign_key_check").get() !== undefined)
+        throw new Error("Akuma Heart upgrade found broken foreign key relationships");
+}
+function timelineSchema(table) {
+    return `CREATE TABLE ${table === "timeline" ? "IF NOT EXISTS " : ""}${table} (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end', 'report'))
+  ) STRICT;`;
+}
+const REPORT_SCHEMA = `CREATE TABLE IF NOT EXISTS reports (
+  sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,
+  body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
+  turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,
+  text TEXT NOT NULL,
+  at TEXT NOT NULL
+) STRICT;
+CREATE INDEX IF NOT EXISTS reports_by_turn ON reports(turn_sequence);`;
+export const HEART_SCHEMA = `
+  ${VERSION_SCHEMA}
+  CREATE TABLE IF NOT EXISTS soul (
+    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))
   ) STRICT;
-  CREATE TABLE IF NOT EXISTS timeline (
+  CREATE TABLE IF NOT EXISTS bodies (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))
+    leash_taken_at TEXT NOT NULL,
+    hung_diagnostic TEXT,
+    hung_at TEXT,
+    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),
+    ended_at TEXT,
+    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)
+      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))
+  ) STRICT;
+  CREATE TABLE IF NOT EXISTS sessions (
+    sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+    provider TEXT NOT NULL,
+    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),
+    cwd TEXT NOT NULL,
+    options_json TEXT NOT NULL CHECK (json_valid(options_json)),
+    admitted_at TEXT NOT NULL
   ) STRICT;
+  ${turnSchema("turns")}
+  ${timelineSchema("timeline")}
+  ${REPORT_SCHEMA}
   CREATE TABLE IF NOT EXISTS activity_retention (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
     checked_sequence INTEGER NOT NULL

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

@@ -35,6 +35,9 @@ export function decodeSoulSeed(value) {
     const provider = decodeProviderRecipe(soul.provider);
     const options = decodeProviderOptions(soul.options);
     const caller = decodeAkumaCaller(soul.caller);
+    if (soul.bare !== undefined && typeof soul.bare !== "boolean") {
+        throw new Error("Akuma soul bare must be a boolean");
+    }
     return {
         id,
         archetype,
@@ -45,6 +48,7 @@ export function decodeSoulSeed(value) {
         origin: akumaOriginSchema.parse(soul.origin),
         ...(caller === undefined ? {} : { caller }),
         allowed: historicalAllowedActions(soul.allowed),
+        ...(soul.bare === undefined ? {} : { bare: soul.bare }),
     };
 }
 function deepFreeze(value) {

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

@@ -47,6 +47,7 @@ export declare class HeldAkumaLeash {
     completeInterruptBarrier(paths: AkumaPaths, expected?: PauseFact): Promise<InterruptCompletion>;
     recordBody(paths: AkumaPaths, input: Readonly<{
         leashTakenAt: string;
+        handoffFromBodySequence?: number;
     }>): Promise<BodyFact>;
     recordBodyHung(paths: AkumaPaths, input: Readonly<{
         sequence: number;

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

@@ -3,9 +3,9 @@ import { lstat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { setTimeout } from "node:timers/promises";
 import { BodyControlledError } from "./facts.js";
-import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, } from "./schema.js";
-import { deleteStopControl, completeInterruptBarrier as judgeInterruptBarrier, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
-import { insertTellFact } from "./tells.js";
+import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, heartSchemaVersion, upgradeHeartSchema, } from "./schema.js";
+import { deleteStopControl, completeInterruptBarrier as judgeInterruptBarrier, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, hasBodyHandoffControl, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
+import { insertTellFact, resolveTellDispositionSnapshot, tellDispositionResolved } from "./tells.js";
 import { pruneActivityFacts } from "./timeline.js";
 import { insertSoulFact, soulFact } from "./soul.js";
 const ACTIVITY_LIMIT = 5_000;
@@ -46,16 +46,43 @@ async function openExistingDatabase(path, timeout, mode = "rw") {
         throw error;
     }
 }
-async function openHeart(path, mode) {
+async function openHeart(path, mode, signal) {
     const database = await openExistingDatabase(path, 0, mode);
     try {
         database.exec("PRAGMA foreign_keys=ON; PRAGMA busy_timeout=0");
-        return database;
+        const version = await acquire(() => {
+            const version = heartSchemaVersion(database);
+            if (version !== 29 && version !== 30)
+                assertHeartSchemaVersion(database);
+            return version;
+        }, signal);
+        if (version !== 29 && version !== 30)
+            return database;
     }
     catch (error) {
         database.close();
         throw error;
     }
+    database.close();
+    // Current-format reads never acquire a writer. Only the known predecessors
+    // need one, and no read transaction survives across the conversion.
+    const writer = await openExistingDatabase(path, 0);
+    try {
+        // Dropping turns with FK enforcement enabled would cascade into its children.
+        // SQLite requires this switch outside the transaction; check before commit.
+        writer.exec("PRAGMA foreign_keys=OFF; PRAGMA busy_timeout=0");
+        await beginTransaction(writer, "write", signal, heartSchemaVersion);
+        finishTransaction(writer, () => upgradeHeartSchema(writer));
+    }
+    finally {
+        try {
+            writer.exec("PRAGMA foreign_keys=ON");
+        }
+        finally {
+            writer.close();
+        }
+    }
+    return await openHeart(path, mode, signal);
 }
 export async function classifyHeartSchema(paths) {
     let database;
@@ -74,20 +101,15 @@ export async function classifyHeartSchema(paths) {
         database.close();
     }
 }
-async function beginTransaction(database, mode, signal) {
+async function acquire(operation, signal) {
     const deadline = performance.now() + TRANSACTION_ACQUISITION_MS;
     let delay = 10;
     for (;;) {
         signal?.throwIfAborted();
         try {
-            database.exec(mode === "write" ? "BEGIN IMMEDIATE" : "BEGIN DEFERRED");
-            // DEFERRED acquires its snapshot on the first read, not on BEGIN. WAL
-            // recovery and last-connection cleanup can make this read busy too.
-            assertHeartSchemaVersion(database);
-            return;
+            return operation();
         }
         catch (error) {
-            rollbackTransaction(database);
             // Only failed admission can be retried: no caller statement has run.
             const remaining = deadline - performance.now();
             if (!isBusy(error) || remaining <= 0)
@@ -102,9 +124,22 @@ async function beginTransaction(database, mode, signal) {
         }
     }
 }
+async function beginTransaction(database, mode, signal, validate = assertHeartSchemaVersion) {
+    await acquire(() => {
+        try {
+            database.exec(mode === "write" ? "BEGIN IMMEDIATE" : "BEGIN DEFERRED");
+            // DEFERRED acquires its snapshot on the first read, not on BEGIN.
+            validate(database);
+        }
+        catch (error) {
+            rollbackTransaction(database);
+            throw error;
+        }
+    }, signal);
+}
 export async function withReadOnlyHeart(paths, body, signal) {
     signal?.throwIfAborted();
-    const database = await openHeart(paths.heart, "ro");
+    const database = await openHeart(paths.heart, "ro", signal);
     try {
         await beginTransaction(database, "read", signal);
         return finishTransaction(database, body);
@@ -151,7 +186,7 @@ export function createHeartReader(paths) {
                 if (identity?.dev !== current.dev || identity?.ino !== current.ino)
                     release();
                 if (database === undefined) {
-                    database = await openHeart(paths.heart, "ro");
+                    database = await openHeart(paths.heart, "ro", signal);
                     identity = current;
                     opened += 1;
                 }
@@ -170,7 +205,7 @@ export function createHeartReader(paths) {
 }
 export async function withHeartTransaction(paths, body, signal) {
     signal?.throwIfAborted();
-    const database = await openHeart(paths.heart, "rw");
+    const database = await openHeart(paths.heart, "rw", signal);
     try {
         await beginTransaction(database, "write", signal);
         return finishTransaction(database, body);
@@ -282,6 +317,12 @@ export class HeldAkumaLeash {
         if (this.closed || this.bodySequence !== undefined)
             throw new Error("Akuma leash cannot start another Body");
         const sequence = await withHeartTransaction(paths, (heart) => {
+            const predecessor = input.handoffFromBodySequence;
+            if (predecessor !== undefined &&
+                (latestBodyFact(heart)?.sequence !== predecessor ||
+                    hasBodyHandoffControl(heart, predecessor) ||
+                    tellDispositionResolved(heart, predecessor) !== false))
+                throw new BodyControlledError();
             const completion = judgeInterruptBarrier(heart);
             if (completion.kind === "unavailable")
                 throw new BodyControlledError();
@@ -318,6 +359,9 @@ export class HeldAkumaLeash {
             const result = latestKillFact(heart)?.bodySequence === target.bodySequence
                 ? "already-killed"
                 : (insertKillFact(heart, target.bodySequence, target.requestedAt), "recorded");
+            const released = tellDispositionResolved(heart, target.bodySequence) === false;
+            resolveTellDispositionSnapshot(heart, target.bodySequence, target.requestedAt);
+            pruneActivityFacts(heart, ACTIVITY_LIMIT, released);
             deleteStopControl(heart);
             return { target, result };
         });

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

@@ -1,8 +1,8 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { CallFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
-import { type ActivityFact, type ActivityRow, type CallRow, type TurnRow } from "./rows.js";
+import type { CallFact, ReportFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
+import { type ActivityFact, type ReportRow, type ActivityRow, type CallRow, type TurnRow } from "./rows.js";
 import { tellBatchAtSequences } from "./tells.js";
-export type TimelineFact = TurnStartFact | CallFact | ActivityFact | TellFact | TurnEndFact;
+export type TimelineFact = TurnStartFact | CallFact | ReportFact | ActivityFact | TellFact | TurnEndFact;
 export type ActivityFactSlice = Readonly<{
     rows: readonly TimelineFact[];
     lowestRetained: number | null;
@@ -12,12 +12,13 @@ export declare function lastActivityAt(database: DatabaseSync): string | null;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number, protectionReleased?: boolean): void;
 type TimelineRow = Readonly<{
     sequence: number;
-    kind: "turn-start" | "call" | "activity" | "tell" | "turn-end";
+    kind: "turn-start" | "call" | "report" | "activity" | "tell" | "turn-end";
 }>;
 type TimelineBatch = Readonly<{
     rows: readonly TimelineRow[];
     turns: readonly TurnRow[];
     calls: readonly CallRow[];
+    reports: readonly ReportRow[];
     activity: readonly ActivityRow[];
     tells: ReturnType<typeof tellBatchAtSequences>;
 }>;
@@ -31,6 +32,7 @@ export declare function readStatusBatch(database: DatabaseSync, input: StatusFac
     rows: readonly TimelineRow[];
     turns: readonly TurnRow[];
     calls: readonly CallRow[];
+    reports: readonly ReportRow[];
     activity: readonly ActivityRow[];
     tells: ReturnType<typeof tellBatchAtSequences>;
     frontier: number | null;

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

@@ -1,4 +1,4 @@
-import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
+import { decodeReportRow, decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
 import { decodeTellBatch, tellBatchAtSequences, tellStateSql, pendingTellProtectionSql, pendingTellSequencesSql, } from "./tells.js";
 export function lastActivityAt(database) {
     const row = database
@@ -6,6 +6,7 @@ export function lastActivityAt(database) {
       WHEN 'turn-start' THEN started_turn.started_at
       WHEN 'call' THEN calls.at
       WHEN 'activity' THEN activity.at
+      WHEN 'report' THEN reports.at
       WHEN 'tell' THEN tells.recorded_at
       WHEN 'turn-end' THEN ended_turn.completed_at
     END AS at
@@ -13,6 +14,7 @@ export function lastActivityAt(database) {
     LEFT JOIN turns AS started_turn ON timeline.kind = 'turn-start' AND started_turn.sequence = timeline.sequence
     LEFT JOIN calls ON timeline.kind = 'call' AND calls.sequence = timeline.sequence
     LEFT JOIN activity ON timeline.kind = 'activity' AND activity.sequence = timeline.sequence
+    LEFT JOIN reports ON timeline.kind = 'report' AND reports.sequence = timeline.sequence
     LEFT JOIN tells ON timeline.kind = 'tell' AND tells.sequence = timeline.sequence
     LEFT JOIN turns AS ended_turn ON timeline.kind = 'turn-end' AND ended_turn.end_sequence = timeline.sequence
     ORDER BY timeline.sequence DESC LIMIT 1`)
@@ -41,6 +43,7 @@ export function pruneActivityFacts(database, limit, protectionReleased = false)
       SELECT sequence FROM turns WHERE end_sequence IS NULL
       UNION SELECT turn_sequence FROM calls WHERE sequence >= ?
       UNION SELECT turn_sequence FROM activity WHERE sequence >= ?
+      UNION SELECT turn_sequence FROM reports WHERE sequence >= ?
       UNION SELECT sequence FROM turns WHERE end_sequence >= ?
       UNION ${pendingTellProtectionSql}
     ), protected(sequence) AS (
@@ -50,7 +53,7 @@ export function pruneActivityFacts(database, limit, protectionReleased = false)
       UNION ${pendingTellSequencesSql}
     )
     DELETE FROM timeline WHERE sequence < ? AND sequence NOT IN protected`)
-        .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
+        .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
 }
 function readTimelineBatch(database, rows) {
     const sequences = (kind) => JSON.stringify(rows.filter((row) => row.kind === kind).map((row) => row.sequence));
@@ -68,8 +71,12 @@ function readTimelineBatch(database, rows) {
         .prepare(`SELECT sequence, turn_sequence, event_json, at FROM activity
     WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(sequences("activity"));
+    const reports = database
+        .prepare(`SELECT sequence, body_sequence, turn_sequence, text, at
+    FROM reports WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
+        .all(sequences("report"));
     const tells = tellBatchAtSequences(database, rows.filter((row) => row.kind === "tell").map((row) => row.sequence));
-    return { rows, turns, calls, activity, tells };
+    return { rows, turns, calls, reports, activity, tells };
 }
 export function decodeTimelineBatch(batch) {
     const facts = new Map();
@@ -81,6 +88,8 @@ export function decodeTimelineBatch(batch) {
     }
     for (const row of batch.calls)
         facts.set(row.sequence, decodeCallRow(row));
+    for (const row of batch.reports)
+        facts.set(row.sequence, decodeReportRow(row));
     for (const row of batch.activity)
         facts.set(row.sequence, decodeActivityRow(row));
     for (const fact of decodeTellBatch(batch.tells))
@@ -100,6 +109,7 @@ export function readStatusBatch(database, input) {
       SELECT sequence FROM turns WHERE sequence = ?
       UNION SELECT end_sequence FROM turns WHERE sequence = ? AND end_sequence IS NOT NULL
       UNION SELECT sequence FROM calls WHERE turn_sequence = ?
+      UNION SELECT sequence FROM reports WHERE turn_sequence = ?
       UNION SELECT sequence FROM activity WHERE turn_sequence = ?
       UNION SELECT tells.sequence FROM tells
       JOIN tell_deliveries ON tell_deliveries.tell_id = tells.id
@@ -107,7 +117,7 @@ export function readStatusBatch(database, input) {
       UNION SELECT sequence FROM tells WHERE id = ?
       UNION SELECT sequence FROM tells WHERE ? AND ${tellStateSql} = 'pending'
     ) SELECT timeline.sequence, timeline.kind FROM timeline JOIN selected USING(sequence) ORDER BY sequence`)
-        .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0);
+        .all(frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, frontier?.sequence ?? null, input.admittedTellId ?? null, input.aperture === "monitoring" || input.admittedTellId === undefined ? 1 : 0);
     return { frontier: frontier?.sequence ?? null, ...readTimelineBatch(database, rows) };
 }
 export function statusFacts(database, input) {

package/build/src/akuma/in-process-body.d.ts

@@ -0,0 +1,5 @@
+import type { ProviderAdapter } from "./provider.js";
+import { type BodyRuntime } from "./body.js";
+import type { BodyLaunch, LiveBodyLaunch } from "./body-launch.js";
+/** One owned Body in this Node runtime; preparation starts only after custody is returned. */
+export declare function launchInProcessBody(launch: BodyLaunch, prepare: (signal: AbortSignal) => Promise<Pick<BodyRuntime, "world" | "externalCommands" | "spawn" | "requestSpawn" | "executionAssociation">>, adapter?: ProviderAdapter, scopeSignal?: AbortSignal): Promise<LiveBodyLaunch>;

package/build/src/akuma/in-process-body.js

@@ -0,0 +1,57 @@
+import { driveAkumaBody } from "./body.js";
+import { abortable } from "./abort.js";
+/** One owned Body in this Node runtime; preparation starts only after custody is returned. */
+export async function launchInProcessBody(launch, prepare, adapter, scopeSignal) {
+    const controller = new AbortController();
+    const forced = new AbortController();
+    // Scope custody is independent of the publication holder's release below.
+    const closeScope = () => {
+        forced.abort();
+        controller.abort(scopeSignal?.reason);
+    };
+    scopeSignal?.addEventListener("abort", closeScope, { once: true });
+    if (scopeSignal?.aborted)
+        closeScope();
+    let released = false;
+    // A pending SDK/setup Promise alone does not keep Node alive. Release is not
+    // detachment: this Body retains the calling runtime until its drive finishes.
+    const lifetime = setInterval(() => { }, 1_073_741_824);
+    const completed = Promise.resolve()
+        .then(async () => {
+        controller.signal.throwIfAborted();
+        const runtime = await abortable(prepare(controller.signal), controller.signal);
+        controller.signal.throwIfAborted();
+        const result = await driveAkumaBody(launch, adapter, {
+            ...runtime,
+            signal: controller.signal,
+            forceSignal: forced.signal,
+        });
+        if (result === "hung")
+            throw new Error("in-process Body ended with hung provider custody; native work may still be running");
+        return { diagnostic: "in-process Body completed", ...(result === "held" ? { held: true } : {}) };
+    })
+        .catch((error) => {
+        if (controller.signal.aborted && error === controller.signal.reason)
+            return { diagnostic: "in-process Body launch canceled" };
+        throw error;
+    })
+        .finally(() => {
+        scopeSignal?.removeEventListener("abort", closeScope);
+        clearInterval(lifetime);
+    });
+    void completed.catch(() => undefined);
+    return {
+        completed,
+        async cancel(force = false) {
+            if (released)
+                return;
+            if (force)
+                forced.abort();
+            controller.abort(new Error("in-process Body launch canceled"));
+            await completed;
+        },
+        release() {
+            released = true;
+        },
+    };
+}

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

@@ -4,7 +4,7 @@ export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
 export type { ArchetypeCatalog, ArchetypeCatalogInput, ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaReportOptions, AkumaReportResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
 export type { AkumaStreamSnapshot } from "./akuma-stream.js";
 export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";