@astrosheep/keiyaku 4.0.4 → 4.0.6

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 = 16)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 16);\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 (action IN ('akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill')),\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 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 = 20)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 20);\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 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 = 16;
+const HEART_SCHEMA_VERSION = 20;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -28,7 +28,8 @@ export const HEART_SCHEMA = `
     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 AND end IS NULL))
+    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,
@@ -109,7 +110,14 @@ export const HEART_SCHEMA = `
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,
     requester TEXT NOT NULL,
-    action TEXT NOT NULL CHECK (action IN ('akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill')),
+    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')),

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

@@ -6,9 +6,6 @@ function record(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`);
@@ -28,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,
@@ -43,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,
@@ -54,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, ["allowed", "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");
@@ -103,7 +68,6 @@ 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/timeline.d.ts

@@ -7,5 +7,6 @@ export type ActivityFactSlice = Readonly<{
     lowestRetained: number | null;
     highest: number | null;
 }>;
+export declare function lastActivityAt(database: DatabaseSync): string | null;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
 export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;

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

@@ -1,5 +1,24 @@
 import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
 import { decodeTellAtSequence, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
+export function lastActivityAt(database) {
+    const row = database.prepare(`SELECT CASE timeline.kind
+      WHEN 'turn-start' THEN started_turn.started_at
+      WHEN 'call' THEN calls.at
+      WHEN 'activity' THEN activity.at
+      WHEN 'tell' THEN tells.recorded_at
+      WHEN 'turn-end' THEN ended_turn.completed_at
+    END AS at
+    FROM timeline
+    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 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`).get();
+    if (row === undefined || row.at === null)
+        return null;
+    return row.at;
+}
 export function pruneActivityFacts(database, limit) {
     const count = database.prepare("SELECT COUNT(*) AS count FROM timeline").get();
     if (count.count <= limit + 500)

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

@@ -13,5 +13,5 @@ export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHist
 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/nuke.d.ts

@@ -0,0 +1,2 @@
+import type { WorldRoot } from "../world.js";
+export declare function stopAkuma(world: WorldRoot): Promise<() => Promise<void>>;

package/build/src/akuma/nuke.js

@@ -0,0 +1,152 @@
+import { lstat, readdir, rm } from "node:fs/promises";
+import { nukeAliases } from "../alias/index.js";
+import { CONTROL_RESPONSE_MS } from "./body.js";
+import { HeldAkumaLeash, readHeart, readKill, requestStop, } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, } from "./identity.js";
+const POLL_MS = 25;
+async function hasAkumaCustody(paths) {
+    try {
+        const value = await lstat(paths.heart);
+        return value.isFile() && !value.isSymbolicLink();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return false;
+    }
+}
+function wait(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function takeLeashUntil(paths, deadline) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        if (performance.now() >= deadline)
+            return null;
+        await wait(POLL_MS);
+    }
+}
+async function stopRunningAkuma(entry) {
+    const request = await requestStop(entry.paths, new Date().toISOString());
+    const leash = await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+    if (leash === null)
+        throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+    try {
+        if (request.kind === "already-killed" || request.kind === "already-stopped")
+            return leash;
+        if (await readKill(entry.paths, request.body.sequence) !== null)
+            return leash;
+        const current = await readHeart(entry.paths);
+        if (current.latestBody?.sequence !== request.body.sequence) {
+            if (await readKill(entry.paths, request.body.sequence) !== null)
+                return leash;
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        if (current.latestBody.end !== "put-down") {
+            await leash.clearStop(entry.paths);
+            throw new Error(`Akuma ${entry.id} could not be stopped: untidy`);
+        }
+        if (await leash.settleStop(entry.paths, request.body.sequence) === null) {
+            throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
+        }
+        return leash;
+    }
+    catch (error) {
+        leash.release();
+        throw error;
+    }
+}
+async function removeRegularFile(path) {
+    try {
+        const value = await lstat(path);
+        if (value.isFile() && !value.isSymbolicLink())
+            await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function removeAkumaEntry(entry) {
+    for (const path of [entry.paths.heart, entry.paths.log,
+        `${entry.paths.heart}-wal`, `${entry.paths.heart}-shm`]) {
+        await removeRegularFile(path);
+    }
+}
+async function nukeAkumaEntries(world) {
+    const runRoot = akumaRunRoot(world);
+    let names;
+    try {
+        names = (await readdir(runRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            names = [];
+        else
+            throw error;
+    }
+    const entries = [];
+    for (const name of names) {
+        let physical;
+        try {
+            physical = akuIdFromDirectoryName(name);
+        }
+        catch {
+            // The run root can contain bytes not produced by Keiyaku. Preserve them.
+            continue;
+        }
+        const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+        if (!(await hasAkumaCustody(paths)))
+            continue;
+        entries.push({ id: physical.id, paths });
+    }
+    return entries;
+}
+export async function stopAkuma(world) {
+    const entries = await nukeAkumaEntries(world);
+    const held = [];
+    try {
+        for (const entry of entries) {
+            const snapshot = await readHeart(entry.paths);
+            const leash = snapshot.soul !== null && snapshot.latestBody?.end === undefined
+                ? await stopRunningAkuma(entry)
+                : await takeLeashUntil(entry.paths, performance.now() + CONTROL_RESPONSE_MS);
+            if (leash === null)
+                throw new Error(`Akuma ${entry.id} could not be verified stopped`);
+            try {
+                const after = await readHeart(entry.paths);
+                if (after.soul === null || after.latestBody?.end !== undefined) {
+                    held.push(leash);
+                    continue;
+                }
+                throw new Error(`Akuma ${entry.id} stopped without a durable end`);
+            }
+            catch (error) {
+                leash.release();
+                throw error;
+            }
+        }
+        return async () => {
+            try {
+                await nukeAliases(world);
+                for (const entry of entries)
+                    await removeAkumaEntry(entry);
+            }
+            finally {
+                for (const leash of held.reverse())
+                    leash.release();
+            }
+        };
+    }
+    finally {
+        if (held.length !== entries.length) {
+            for (const leash of held.reverse())
+                leash.release();
+        }
+    }
+}

package/build/src/akuma/provider-recipe.js

@@ -24,10 +24,6 @@ export function decodeProviderOptions(value) {
     const options = record(value);
     if (options === null)
         throw new TypeError("provider options must be an object");
-    const allowed = ["effort", "model", "network", "readonly", "systemPrompt"];
-    const unknown = Object.keys(options).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider options have unknown field ${unknown}`);
     const model = optionText(options, "model", "refuse");
     const effort = optionText(options, "effort", "refuse");
     if (options.readonly !== undefined && options.readonly !== true) {
@@ -50,12 +46,10 @@ export function decodeReadonlyRestraint(value) {
     const restraint = record(value);
     if (restraint === null)
         throw new TypeError("readonly restraint must be an object");
-    const keys = Object.keys(restraint).sort();
-    if (restraint.enforcement === "native" && keys.length === 1 && keys[0] === "enforcement") {
+    if (restraint.enforcement === "native") {
         return Object.freeze({ enforcement: "native" });
     }
     if (restraint.enforcement === "none"
-        && keys.length === 2 && keys[0] === "diagnostic" && keys[1] === "enforcement"
         && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
         return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
     }
@@ -69,10 +63,6 @@ export function decodeProviderRecipe(input) {
     const value = record(input);
     if (value === null)
         throw new TypeError("provider execution must be an object");
-    const allowed = ["config", "env", "executable", "kind", "name"];
-    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider execution has unknown field ${unknown}`);
     if (typeof value.name !== "string" || value.name.trim().length === 0) {
         throw new TypeError("provider execution name must be a nonblank string");
     }

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

@@ -1,4 +1,3 @@
-import type { Confinement } from "./heart/index.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
 import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
@@ -122,8 +121,10 @@ export type Session = Readonly<{
     events: AsyncIterable<AgentEvent>;
     receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
-    /** Fulfills after every adapter-owned OS child or native session is disposed. */
+    /** Requests graceful adapter-owned cancellation. */
     abort(): Promise<void>;
+    /** Fulfills only after forced adapter-owned disposal is proved. */
+    forceDispose(): Promise<void>;
     tell?(tell: Readonly<{
         id: string;
         text: string;
@@ -138,7 +139,7 @@ export type DriveInput = Readonly<{
     cwd: string;
     options: ProviderOptions;
     signal: AbortSignal;
-    requests?: Readonly<{
+    requests: Readonly<{
         dir: string;
     }>;
 }>;
@@ -151,10 +152,6 @@ export type ProviderOptionAdmission = Readonly<{
     diagnostic: string;
 }>;
 export type ProviderAdapter = Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): Confinement;
     admitOptions(options: ProviderOptions): ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: ResumeCoordinate;

package/build/src/akuma/providers/acp/config.d.ts

@@ -0,0 +1,8 @@
+export type AcpExecutionConfig = Readonly<{
+    argvBefore: readonly string[];
+    argvAfter: readonly string[];
+    modelArg?: string;
+    effortArg?: string;
+    systemPromptArg?: string;
+}>;
+export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;

package/build/src/akuma/providers/acp/config.js

@@ -0,0 +1,37 @@
+function argumentName(value, key) {
+    const selected = value[key];
+    if (selected === undefined)
+        return undefined;
+    if (typeof selected !== "string" || selected.trim().length === 0) {
+        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
+    }
+    return selected;
+}
+export function decodeAcpConfig(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("ACP provider config must be an object");
+    }
+    const config = value;
+    const unknown = Object.keys(config)
+        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
+    if (!Array.isArray(config.argvBefore)
+        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
+    }
+    if (!Array.isArray(config.argvAfter)
+        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
+        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
+    }
+    const modelArg = argumentName(config, "modelArg");
+    const effortArg = argumentName(config, "effortArg");
+    const systemPromptArg = argumentName(config, "systemPromptArg");
+    return Object.freeze({
+        argvBefore: Object.freeze([...config.argvBefore]),
+        argvAfter: Object.freeze([...config.argvAfter]),
+        ...(modelArg === undefined ? {} : { modelArg }),
+        ...(effortArg === undefined ? {} : { effortArg }),
+        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
+    });
+}

package/build/src/akuma/providers/acp/core.js

@@ -2,7 +2,7 @@ import * as acp from "@agentclientprotocol/sdk";
 import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
 function diagnostic(error) {
     if (!(error instanceof Error))
@@ -122,6 +122,12 @@ function beginAcpPrompt(agent, child, turn, sessionId, input) {
             else
                 await turn.finish(result, () => child.close(true));
         },
+        forceDispose: async () => {
+            if (!turn.open())
+                await child.close(true);
+            else
+                await turn.finish({ kind: "failed", diagnostic: "ACP turn force-disposed" }, () => child.close(true));
+        },
     };
 }
 export async function startAcpSession(launch, input, dependencies = {}) {
@@ -130,7 +136,11 @@ export async function startAcpSession(launch, input, dependencies = {}) {
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
         argv: launch.argv,
         cwd: input.cwd,
-        env: { ...globalThis.process.env, ...launch.env },
+        env: {
+            ...globalThis.process.env,
+            ...launch.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
     });
     let sessionId;
     let turn;

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

@@ -1,12 +1,5 @@
 import type { ProviderAdapter } from "../../provider.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
 import { type AcpDependencies } from "./core.js";
-export type AcpExecutionConfig = Readonly<{
-    argvBefore: readonly string[];
-    argvAfter: readonly string[];
-    modelArg?: string;
-    effortArg?: string;
-    systemPromptArg?: string;
-}>;
-export declare function decodeAcpConfig(value: unknown): AcpExecutionConfig;
+export { decodeAcpConfig, type AcpExecutionConfig } from "./config.js";
 export declare function createAcpProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;

package/build/src/akuma/providers/acp/index.js

@@ -1,41 +1,6 @@
+import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
-function argumentName(value, key) {
-    const selected = value[key];
-    if (selected === undefined)
-        return undefined;
-    if (typeof selected !== "string" || selected.trim().length === 0) {
-        throw new TypeError(`ACP provider config ${key} must be a nonblank string`);
-    }
-    return selected;
-}
-export function decodeAcpConfig(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-        throw new TypeError("ACP provider config must be an object");
-    }
-    const config = value;
-    const unknown = Object.keys(config)
-        .find((key) => !["argvBefore", "argvAfter", "effortArg", "modelArg", "systemPromptArg"].includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`ACP provider config has unknown field ${unknown}`);
-    if (!Array.isArray(config.argvBefore)
-        || config.argvBefore.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvBefore must be an array of nonblank strings");
-    }
-    if (!Array.isArray(config.argvAfter)
-        || config.argvAfter.some((arg) => typeof arg !== "string" || arg.trim().length === 0)) {
-        throw new TypeError("ACP provider config argvAfter must be an array of nonblank strings");
-    }
-    const modelArg = argumentName(config, "modelArg");
-    const effortArg = argumentName(config, "effortArg");
-    const systemPromptArg = argumentName(config, "systemPromptArg");
-    return Object.freeze({
-        argvBefore: Object.freeze([...config.argvBefore]),
-        argvAfter: Object.freeze([...config.argvAfter]),
-        ...(modelArg === undefined ? {} : { modelArg }),
-        ...(effortArg === undefined ? {} : { effortArg }),
-        ...(systemPromptArg === undefined ? {} : { systemPromptArg }),
-    });
-}
+export { decodeAcpConfig } from "./config.js";
 function optionAdmission(options, config) {
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "ACP provider does not support the network option" };
@@ -86,7 +51,6 @@ export function createAcpProvider(execution, dependencies = {}) {
         return (await startAcpSession(launch, input, dependencies)).session;
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: (options) => optionAdmission(options, config),
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

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

@@ -21,10 +21,6 @@ export type ClaudeSdk = Readonly<{
 }>;
 export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: ClaudeExecution): ProviderAdapter;
 export declare const claudeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: ResumeCoordinate;

package/build/src/akuma/providers/claude/index.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { emitClaudeMessage, } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
@@ -61,8 +61,13 @@ function claudeQueryOptions(input, execution, abortController) {
     return {
         cwd: input.cwd,
         abortController,
+        ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+        ...((execution.env === undefined && input.requests === undefined) ? {} : { env: {
+                ...process.env,
+                ...execution.env,
+                ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+            } }),
         permissionMode: mode,
         ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         settingSources: ["user", "project", "local"],
@@ -264,12 +269,16 @@ async function driveClaude(load, execution, drive) {
         },
         async abort() {
             shutDown(new Error("Claude query aborted"));
+            await observed.completion;
+        },
+        async forceDispose() {
+            shutDown(new Error("Claude query force-disposed"));
+            await observed.completion;
         },
     };
 }
 export function createClaudeProvider(load, execution = {}) {
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: admitClaudeOptions,
         fork: (input) => forkClaude(load, execution, input),
         start: (input) => driveClaude(load, execution, input),

package/build/src/akuma/providers/codex-app-server/index.d.ts

@@ -1,29 +1,4 @@
-import { type Session, type ProviderAdapter } from "../../provider.js";
-import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 export declare function createCodexAppServerProvider(input?: string | ProviderExecution): ProviderAdapter;
-export declare const codexAppServerProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-    }>>;
-    start(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "fresh";
-        }>;
-    }>): Promise<Session>;
-    resume?(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "resume";
-            coordinate: import("../../coordinate.js").ResumeCoordinate;
-        }>;
-    }>): Promise<Session>;
-}>;