@astrosheep/keiyaku 4.0.3 → 4.0.5

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

@@ -0,0 +1,119 @@
+import { insertRequestFact, nonterminalRequestFacts, requestFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, updateUpstreamRequestServed, } from "./request-rows.js";
+import { transaction, withHeart } from "./storage.js";
+import { soulFact } from "./soul.js";
+import { clipAllowedActions } from "../allowed.js";
+import { requestPayloadJson } from "./request-rows.js";
+export async function admitRequest(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const soul = soulFact(heart);
+        if (soul === null)
+            throw new Error("Akuma request admission requires a born Soul");
+        const action = input.action;
+        const parentAllowed = soul.allowed;
+        const permitted = action === "akuma.wait" || parentAllowed.includes(action);
+        const normalized = input.action === "akuma.call"
+            ? {
+                ...input,
+                recipe: {
+                    ...input.recipe,
+                    allowed: permitted ? clipAllowedActions(input.recipe.allowed, parentAllowed) : input.recipe.allowed,
+                },
+            }
+            : input;
+        insertRequestFact(heart, {
+            ...normalized,
+            requester: soul.id,
+            admittedAt: input.admittedAt,
+            ...(permitted ? {} : { refusal: `not-allowed: ${action}` }),
+        });
+        const fact = requestFact(heart, input.id);
+        if (fact === null)
+            throw new Error(`Akuma request ${input.id} was not admitted`);
+        if (fact.requester !== soul.id
+            || fact.id !== normalized.id
+            || fact.action !== normalized.action
+            || requestPayloadJson(fact) !== requestPayloadJson(normalized)) {
+            throw new Error(`Akuma request ${input.id} reused different input`);
+        }
+        return fact;
+    }));
+}
+export async function reserveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action !== "akuma.call")
+            throw new Error(`Akuma request ${id} cannot reserve a child`);
+        if (before.state === "admitted")
+            updateRequestReserved(heart, id, child);
+        else if ((before.state !== "reserved" && before.state !== "served") || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot reserve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function serveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action !== "akuma.call")
+            throw new Error(`Akuma request ${id} cannot serve a child`);
+        if (before.state === "reserved" && before.child === child)
+            updateRequestServed(heart, id, child);
+        else if (before.state !== "served" || before.child !== child) {
+            throw new Error(`Akuma request ${id} cannot serve ${child}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function serveUpstreamRequest(paths, id, service) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
+        const before = requestFact(heart, id);
+        if (before === null)
+            throw new Error(`unknown Akuma request ${id}`);
+        if (before.action === "akuma.call" || service.action !== before.action) {
+            throw new Error(`Akuma request ${id} has a mismatched service reference`);
+        }
+        if (before.state === "admitted")
+            updateUpstreamRequestServed(heart, id, service);
+        else if (before.state !== "served") {
+            throw new Error(`Akuma request ${id} cannot be served as ${service.action}`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function refuseRequest(paths, id, diagnostic) {
+    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")
+            updateRequestRefused(heart, id, diagnostic);
+        else if (before.state !== "refused" || before.diagnostic !== diagnostic) {
+            throw new Error(`Akuma request ${id} cannot be refused`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function voidRequest(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 === "admitted" || before.state === "reserved") {
+            updateRequestVoided(heart, id, evidence);
+        }
+        else if (before.state !== "voided" || before.evidence !== evidence) {
+            throw new Error(`Akuma request ${id} cannot be voided`);
+        }
+        return requestFact(heart, id);
+    }));
+}
+export async function readRequest(paths, id) {
+    return await withHeart(paths, (heart) => requestFact(heart, id));
+}
+export async function readNonterminalRequests(paths) {
+    return await withHeart(paths, nonterminalRequestFacts);
+}

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

@@ -0,0 +1,16 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { AkuId } from "../identity.js";
+import type { RequestFact, RequestInput } from "./facts.js";
+export declare function requestPayloadJson(input: RequestInput): string;
+export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
+    requester: AkuId;
+    admittedAt: string;
+    refusal?: string;
+}>): void;
+export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
+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 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;

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

@@ -0,0 +1,88 @@
+import { isTaskMutationAction } from "../../task/mutation.js";
+function json(value) {
+    return JSON.stringify(value);
+}
+function parsed(value) {
+    if (typeof value !== "string")
+        throw new Error("Akuma authority contains non-text JSON");
+    return JSON.parse(value);
+}
+export function requestPayloadJson(input) {
+    const { id: _id, action: _action, requester: _requester, admittedAt: _admittedAt, state: _state, child: _child, service: _service, diagnostic: _diagnostic, evidence: _evidence, refusal: _refusal, ...payload } = input;
+    return json(payload);
+}
+function decodeRequestRow(row) {
+    const knownAction = [
+        "akuma.call", "akuma.wait", "akuma.tell", "akuma.kill", "contract.deliver", "contract.review",
+    ].includes(row.action) || isTaskMutationAction(row.action);
+    if (!knownAction)
+        throw new Error(`Akuma authority contains an unknown request action: ${row.action}`);
+    const payload = parsed(row.payload_json);
+    const input = {
+        id: row.id,
+        requester: row.requester,
+        action: row.action,
+        ...payload,
+        admittedAt: row.admitted_at,
+    };
+    if (row.state === "reserved") {
+        if (input.action !== "akuma.call" || row.child === null) {
+            throw new Error("Akuma authority contains an invalid reserved request");
+        }
+        return { ...input, state: row.state, child: row.child };
+    }
+    if (row.state === "served") {
+        if (input.action === "akuma.call") {
+            if (row.child === null)
+                throw new Error("Akuma authority contains a served call without a child");
+            return { ...input, state: row.state, child: row.child };
+        }
+        if (row.service_json === null) {
+            throw new Error("Akuma authority contains a served request without a service reference");
+        }
+        const service = parsed(row.service_json);
+        return { ...input, state: row.state, service };
+    }
+    if (row.state === "refused")
+        return { ...input, state: row.state, diagnostic: row.diagnostic };
+    if (row.state === "voided")
+        return { ...input, state: row.state, evidence: row.evidence };
+    return { ...input, state: "admitted" };
+}
+const REQUEST_COLUMNS = `sequence, id, requester, action, payload_json, admitted_at,
+  state, child, service_json, diagnostic, evidence`;
+export function insertRequestFact(database, input) {
+    const { id, action, requester, admittedAt, refusal } = input;
+    database.prepare(`INSERT OR IGNORE INTO requests(
+    id, requester, action, payload_json, admitted_at, state, diagnostic
+  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, requester, action, requestPayloadJson(input), admittedAt, refusal === undefined ? "admitted" : "refused", refusal ?? null);
+}
+export function requestFact(database, id) {
+    const row = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests WHERE id = ?`).get(id);
+    return row === undefined ? null : decodeRequestRow(row);
+}
+export function nonterminalRequestFacts(database) {
+    const rows = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests
+    WHERE state IN ('admitted', 'reserved') ORDER BY sequence`).all();
+    return rows.map(decodeRequestRow);
+}
+export function updateRequestReserved(database, id, child) {
+    database.prepare("UPDATE requests SET state = 'reserved', child = ? WHERE id = ? AND state = 'admitted'")
+        .run(child, id);
+}
+export function updateRequestServed(database, id, child) {
+    database.prepare(`UPDATE requests SET state = 'served', child = ?
+    WHERE id = ? AND state = 'reserved'`).run(child, id);
+}
+export function updateUpstreamRequestServed(database, id, service) {
+    database.prepare(`UPDATE requests SET state = 'served', service_json = ?
+    WHERE id = ? AND state = 'admitted' AND action != 'akuma.call'`).run(json(service), id);
+}
+export function updateRequestRefused(database, id, diagnostic) {
+    database.prepare(`UPDATE requests SET state = 'refused', diagnostic = ?
+    WHERE id = ? AND state = 'admitted'`).run(diagnostic, id);
+}
+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')`).run(evidence, id);
+}

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

@@ -1,6 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { AkuId } from "../identity.js";
-import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, RequestFact, RequestInput, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+import type { BodyEnd, BodyFact, CallFact, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 export type SealRow = Readonly<{
     evidence: string;
     at: string;
@@ -39,20 +38,6 @@ export type CallRow = Readonly<{
     body: string;
     at: string;
 }>;
-export type RequestRow = Readonly<{
-    sequence: number;
-    id: string;
-    archetype: string;
-    body: string;
-    cwd: string | null;
-    world: string;
-    recipe_json: string;
-    admitted_at: string;
-    state: RequestFact["state"];
-    child: string | null;
-    diagnostic: string | null;
-    evidence: string | null;
-}>;
 export type ActivityRow = Readonly<{
     sequence: number;
     turn_sequence: number;
@@ -78,7 +63,6 @@ export declare function decodeSessionRow(row: SessionRow): SessionFact;
 export declare function decodeBodyRow(row: BodyRow): BodyFact;
 export declare function decodeTurnRow(row: TurnRow): TurnFact;
 export declare function decodeCallRow(row: CallRow): CallFact;
-export declare function decodeRequestRow(row: RequestRow): RequestFact;
 export declare function encodeActivityEvent(event: unknown): string;
 export declare function decodeActivityRow(row: ActivityRow): ActivityFact;
 export declare function sealExists(database: DatabaseSync): boolean;
@@ -101,15 +85,6 @@ export declare function insertActivityFact(database: DatabaseSync, input: Readon
     event: unknown;
     at: string;
 }>): number;
-export declare function insertRequestFact(database: DatabaseSync, input: RequestInput & Readonly<{
-    admittedAt: string;
-}>): void;
-export declare function requestFact(database: DatabaseSync, id: string): RequestFact | null;
-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 updateRequestRefused(database: DatabaseSync, id: string, diagnostic: string): void;
-export declare function updateRequestVoided(database: DatabaseSync, id: string, evidence: string): void;
 export declare function insertStopControl(database: DatabaseSync, bodySequence: number, at: string): void;
 export declare function insertPauseControl(database: DatabaseSync, at: string): void;
 export declare function stopFact(database: DatabaseSync): StopFact | null;

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

@@ -66,25 +66,6 @@ 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 decodeRequestRow(row) {
-    const input = {
-        id: row.id,
-        archetype: row.archetype,
-        body: row.body,
-        ...(row.cwd === null ? {} : { cwd: row.cwd }),
-        world: row.world,
-        recipe: parsed(row.recipe_json),
-        admittedAt: row.admitted_at,
-    };
-    if (row.state === "reserved" || row.state === "served") {
-        return { ...input, state: row.state, child: row.child };
-    }
-    if (row.state === "refused")
-        return { ...input, state: row.state, diagnostic: row.diagnostic };
-    if (row.state === "voided")
-        return { ...input, state: row.state, evidence: row.evidence };
-    return { ...input, state: "admitted" };
-}
 export function encodeActivityEvent(event) {
     return json(event);
 }
@@ -129,37 +110,6 @@ export function insertActivityFact(database, input) {
         .run(sequence, input.turnSequence, encodeActivityEvent(input.event), input.at);
     return sequence;
 }
-const REQUEST_COLUMNS = `sequence, id, archetype, body, cwd, world, recipe_json, admitted_at,
-  state, child, diagnostic, evidence`;
-export function insertRequestFact(database, input) {
-    database.prepare(`INSERT OR IGNORE INTO requests(id, archetype, body, cwd, world, recipe_json, admitted_at, state)
-    VALUES (?, ?, ?, ?, ?, ?, ?, 'admitted')`).run(input.id, input.archetype, input.body, input.cwd ?? null, input.world, json(input.recipe), input.admittedAt);
-}
-export function requestFact(database, id) {
-    const row = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests WHERE id = ?`).get(id);
-    return row === undefined ? null : decodeRequestRow(row);
-}
-export function nonterminalRequestFacts(database) {
-    const rows = database.prepare(`SELECT ${REQUEST_COLUMNS} FROM requests
-    WHERE state IN ('admitted', 'reserved') ORDER BY sequence`).all();
-    return rows.map(decodeRequestRow);
-}
-export function updateRequestReserved(database, id, child) {
-    database.prepare("UPDATE requests SET state = 'reserved', child = ? WHERE id = ? AND state = 'admitted'")
-        .run(child, id);
-}
-export function updateRequestServed(database, id, child) {
-    database.prepare(`UPDATE requests SET state = 'served', child = ?
-    WHERE id = ? AND state = 'reserved'`).run(child, id);
-}
-export function updateRequestRefused(database, id, diagnostic) {
-    database.prepare(`UPDATE requests SET state = 'refused', diagnostic = ?
-    WHERE id = ? AND state = 'admitted'`).run(diagnostic, id);
-}
-export function updateRequestVoided(database, id, evidence) {
-    database.prepare(`UPDATE requests SET state = 'voided', child = NULL, evidence = ?
-    WHERE id = ? AND state IN ('admitted', 'reserved')`).run(evidence, id);
-}
 export function insertStopControl(database, bodySequence, at) {
     database.prepare("INSERT OR IGNORE INTO control(kind, value_json, at) VALUES ('stop', ?, ?)")
         .run(json({ bodySequence }), at);

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
-export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 14)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 14);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    archetype TEXT NOT NULL,\n    body TEXT NOT NULL,\n    cwd TEXT,\n    world TEXT NOT NULL,\n    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
+export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 19)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 19);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL) OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL AND end IS NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL)\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL AND answer IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind) WHERE evidence = 'exact';\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind) WHERE evidence = 'fence';\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL CHECK (\n      action IN (\n        'akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill',\n        'contract.deliver', 'contract.review',\n        'task.add', 'task.addDocument', 'task.compose', 'task.update', 'task.start',\n        'task.stop', 'task.hold', 'task.resume', 'task.done', 'task.drop'\n      )\n    ),\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND action = 'akuma.call'\n        AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((action = 'akuma.call' AND child IS NOT NULL AND service_json IS NULL)\n          OR (action != 'akuma.call' AND child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
 export declare const 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 = 14;
+const HEART_SCHEMA_VERSION = 19;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -108,21 +108,33 @@ export const HEART_SCHEMA = `
   CREATE TABLE IF NOT EXISTS requests (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,
-    archetype TEXT NOT NULL,
-    body TEXT NOT NULL,
-    cwd TEXT,
-    world TEXT NOT NULL,
-    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),
+    requester TEXT NOT NULL,
+    action TEXT NOT NULL CHECK (
+      action IN (
+        'akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill',
+        'contract.deliver', 'contract.review',
+        'task.add', 'task.addDocument', 'task.compose', 'task.update', 'task.start',
+        'task.stop', 'task.hold', 'task.resume', 'task.done', 'task.drop'
+      )
+    ),
+    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),
     admitted_at TEXT NOT NULL,
     state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),
     child TEXT,
+    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),
     diagnostic TEXT,
     evidence TEXT,
     CHECK (
-      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)
-      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)
-      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
-      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
+      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'reserved' AND action = 'akuma.call'
+        AND child IS NOT NULL AND service_json IS NULL
+        AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'served'
+        AND ((action = 'akuma.call' AND child IS NOT NULL AND service_json IS NULL)
+          OR (action != 'akuma.call' AND child IS NULL AND service_json IS NOT NULL))
+        AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
+      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
     )
   ) STRICT;
   CREATE TABLE IF NOT EXISTS control (

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

@@ -1,13 +1,11 @@
 import { parseAkuId } from "../identity.js";
 import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint, } from "../provider-recipe.js";
+import { effectiveAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
         : null;
 }
-function unknownKey(value, allowed) {
-    return Object.keys(value).find((key) => !allowed.includes(key));
-}
 function nonblank(value, what) {
     if (typeof value !== "string" || value.trim().length === 0) {
         throw new Error(`Akuma soul ${what} must be a nonblank string`);
@@ -27,14 +25,9 @@ function decodeOrigin(value) {
     if (origin === null)
         throw new Error("Akuma soul origin must be an object");
     if (origin.kind === "direct") {
-        if (unknownKey(origin, ["kind"]) !== undefined)
-            throw new Error("Akuma soul direct origin must have only kind");
         return { kind: "direct" };
     }
     if (origin.kind === "request") {
-        if (unknownKey(origin, ["kind", "parent", "requestId"]) !== undefined) {
-            throw new Error("Akuma soul request origin must have only kind, parent, and requestId");
-        }
         return {
             kind: "request",
             parent: soulAkuIdentity(origin.parent, "request parent").id,
@@ -42,9 +35,6 @@ function decodeOrigin(value) {
         };
     }
     if (origin.kind === "fork") {
-        if (unknownKey(origin, ["at", "kind", "parent"]) !== undefined) {
-            throw new Error("Akuma soul fork origin must have only kind, parent, and at");
-        }
         return {
             kind: "fork",
             parent: soulAkuIdentity(origin.parent, "fork parent").id,
@@ -53,34 +43,10 @@ function decodeOrigin(value) {
     }
     throw new Error("Akuma soul origin must be direct, request, or fork");
 }
-function decodeConfinement(value) {
-    const confinement = record(value);
-    if (confinement === null)
-        throw new Error("Akuma soul confinement must be an object");
-    if (confinement.kind === "unconfined") {
-        if (unknownKey(confinement, ["kind"]) !== undefined)
-            throw new Error("Akuma soul unconfined confinement must have only kind");
-        return { kind: "unconfined" };
-    }
-    if (confinement.kind === "declared") {
-        if (unknownKey(confinement, ["kind", "writableRoots"]) !== undefined) {
-            throw new Error("Akuma soul declared confinement must have only kind and writableRoots");
-        }
-        if (!Array.isArray(confinement.writableRoots)
-            || confinement.writableRoots.some((root) => typeof root !== "string" || root.trim().length === 0)) {
-            throw new Error("Akuma soul declared confinement writableRoots must be nonblank strings");
-        }
-        return { kind: "declared", writableRoots: [...confinement.writableRoots] };
-    }
-    throw new Error("Akuma soul confinement must be unconfined or declared");
-}
 function validateSoul(value) {
     const soul = record(value);
     if (soul === null)
         throw new Error("Akuma soul must be an object");
-    if (unknownKey(soul, ["archetype", "confinement", "createdAt", "cwd", "description", "id", "options", "origin", "provider", "readonly"]) !== undefined) {
-        throw new Error("Akuma soul has an unknown field");
-    }
     const identity = soulAkuIdentity(soul.id, "id");
     const id = identity.id;
     const archetype = nonblank(soul.archetype, "name");
@@ -102,7 +68,7 @@ function validateSoul(value) {
         ...(restraint === undefined ? {} : { readonly: restraint }),
         cwd: nonblank(soul.cwd, "cwd"),
         origin: decodeOrigin(soul.origin),
-        confinement: decodeConfinement(soul.confinement),
+        allowed: effectiveAllowedActions(soul.allowed),
         createdAt: nonblank(soul.createdAt, "createdAt"),
     };
 }

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

@@ -9,6 +9,7 @@ export declare class HeartAbsentError extends Error {
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
 export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
+export declare function readTransaction<T>(database: DatabaseSync, body: () => T): T;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;

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

@@ -84,6 +84,21 @@ export function transaction(database, body) {
         throw error;
     }
 }
+export function readTransaction(database, body) {
+    database.exec("BEGIN DEFERRED");
+    try {
+        const result = body();
+        database.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch { /* preserve the original failure */ }
+        throw error;
+    }
+}
 export async function initializeHeart(paths) {
     const heart = new DatabaseSync(paths.heart);
     try {

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

@@ -8,8 +8,4 @@ export type ActivityFactSlice = Readonly<{
     highest: number | null;
 }>;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
-export declare function activityFactSlice(database: DatabaseSync, input: Readonly<{
-    before?: number;
-    since?: number;
-    limit: number;
-}>): ActivityFactSlice;
+export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;

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

@@ -64,23 +64,14 @@ function decodeTimelineRow(database, row) {
     }
     return decodeTellAtSequence(database, row.sequence);
 }
-export function activityFactSlice(database, input) {
+export function activityFactSlice(database) {
     const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline")
         .get();
-    let rows;
-    if (input.before !== undefined) {
-        rows = database.prepare(`SELECT * FROM (
-      SELECT sequence, kind FROM timeline WHERE sequence < ? ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.before, input.limit);
-    }
-    else if (input.since !== undefined) {
-        rows = database.prepare(`SELECT sequence, kind FROM timeline WHERE sequence > ? ORDER BY sequence LIMIT ?`)
-            .all(input.since, input.limit);
-    }
-    else {
-        rows = database.prepare(`SELECT * FROM (
-      SELECT sequence, kind FROM timeline ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.limit);
-    }
-    return { rows: rows.map((row) => decodeTimelineRow(database, row)), lowestRetained: bounds.lowest, highest: bounds.highest };
+    const rows = database.prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
+        .all();
+    return {
+        rows: rows.map((row) => decodeTimelineRow(database, row)),
+        lowestRetained: bounds.lowest,
+        highest: bounds.highest,
+    };
 }

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

@@ -1,14 +1,17 @@
 import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export type { AkumaCallInput } from "./akuma.js";
+export { ALLOWED_ACTIONS } from "./allowed.js";
+export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";
 export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
 export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
 export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, UnbornAkumaListRow, } from "./akuma.js";
-export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
+export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";
-export type { Confinement, KillEvidence, ResumeCoordinate, TurnFact, } from "./heart/index.js";
+export type { KillEvidence, ResumeCoordinate, TurnFact, } from "./heart/index.js";
 export type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";

package/build/src/akuma/index.js

@@ -1,6 +1,7 @@
 import { readSoul } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { ALLOWED_ACTIONS } from "./allowed.js";
 export async function probeBornAkuma(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));
     return soul !== null;