@astrosheep/keiyaku 4.0.2 → 4.0.4

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 = 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 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 = 16;
 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,26 @@ 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')),
+    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,5 +1,6 @@
 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
@@ -78,7 +79,7 @@ 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) {
+    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");
@@ -103,6 +104,7 @@ function validateSoul(value) {
         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;
@@ -21,6 +22,7 @@ export declare class HeldAkumaLeash {
         evidence: string;
         at: string;
     }>): Promise<"born" | "sealed">;
+    readSeal(): ReturnType<typeof sealFact>;
     clearPause(paths: AkumaPaths): Promise<void>;
     clearStop(paths: AkumaPaths): Promise<void>;
     recordBody(paths: AkumaPaths, input: Readonly<{

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 {
@@ -136,6 +151,8 @@ export class HeldAkumaLeash {
         }));
     }
     async sealIfUnborn(paths, input) {
+        if (sealExists(this.database))
+            return "sealed";
         if (await withHeart(paths, (heart) => soulFact(heart)) !== null)
             return "born";
         insertSealFact(this.database, input);
@@ -144,6 +161,9 @@ export class HeldAkumaLeash {
         this.database.close();
         return "sealed";
     }
+    readSeal() {
+        return sealFact(this.database);
+    }
     async clearPause(paths) { await withHeart(paths, deletePauseControl); }
     async clearStop(paths) { await withHeart(paths, deleteStopControl); }
     async recordBody(paths, input) {

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,13 +1,16 @@
 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";

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;

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

@@ -114,21 +114,35 @@ export type ActivitySnapshotEntry<Row extends SnapshotRow = SnapshotRow> = Reado
     kind: "gap";
     count: number;
 }>;
+export type ReportedFileChange = Readonly<{
+    sequence: number;
+    at: string;
+    op: "add" | "update" | "delete" | "unspecified";
+    path: string;
+    diffstat?: Readonly<{
+        added: number;
+        removed: number;
+    }>;
+}>;
+type ReportedChangeSummary = Readonly<{
+    reportedChanges: readonly ReportedFileChange[];
+    reportedChangesOmitted: number;
+}>;
 export type Snapshot = Readonly<{
     kind: "unborn";
     entries: readonly [];
     omitted: 0;
-}> | Readonly<{
+} & ReportedChangeSummary> | Readonly<{
     kind: "open";
     turn: TurnStartRow;
     entries: readonly ActivitySnapshotEntry<OpenSnapshotRow>[];
     omitted: number;
-}> | Readonly<{
+} & ReportedChangeSummary> | Readonly<{
     kind: "idle";
     outcome?: OutcomeRow;
     entries: readonly ActivitySnapshotEntry<IdleSnapshotRow>[];
     omitted: number;
-}>;
+} & ReportedChangeSummary>;
 export type ActivitySnapshot = Snapshot;
 export type ActivityHistory = Readonly<{
     rows: readonly ActivityRow[];

package/build/src/akuma/projection.js

@@ -1,6 +1,8 @@
 import { decodeAgentEvent } from "./provider.js";
 const DEFAULT_TAIL = 3;
 const DEFAULT_VOICE = 3;
+const REPORTED_CHANGE_LIMIT = 5;
+const EMPTY_REPORTED = { reportedChanges: [], reportedChangesOmitted: 0 };
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -204,11 +206,45 @@ export function ordinarySelectedCount(snapshot) {
         return count + 1;
     }, 0);
 }
+function isSuccessfulFileChange(row) {
+    return row.kind === "tool"
+        && typeof row.state === "object"
+        && row.state.status === "ok"
+        && row.call.kind === "fileChange";
+}
+function flattenReportedChanges(rows) {
+    return rows.flatMap((row) => {
+        if (!isSuccessfulFileChange(row))
+            return [];
+        return row.call.changes.map((change) => ({
+            sequence: row.sequence,
+            at: row.at,
+            op: change.op,
+            path: change.path,
+            ...(change.diffstat === undefined ? {} : { diffstat: change.diffstat }),
+        }));
+    });
+}
+function summarizeReportedChanges(rows) {
+    const eligible = flattenReportedChanges(rows);
+    return {
+        reportedChanges: eligible.slice(-REPORTED_CHANGE_LIMIT),
+        reportedChangesOmitted: Math.max(0, eligible.length - REPORTED_CHANGE_LIMIT),
+    };
+}
+function frontierReportedChanges(ledger) {
+    if (ledger.openTurn !== undefined)
+        return summarizeReportedChanges(ledger.openTurn.rows);
+    const closed = ledger.turns.findLast((turn) => turn.kind === "closed");
+    return closed === undefined ? EMPTY_REPORTED : summarizeReportedChanges(closed.rows);
+}
 /** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
 export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE }) {
-    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
-        return { kind: "unborn", entries: [], omitted: 0 };
+    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell")) {
+        return { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED };
+    }
     const pending = ledger.rows.filter((row) => row.kind === "tell" && row.state === "pending");
+    const reported = frontierReportedChanges(ledger);
     if (ledger.openTurn !== undefined) {
         const window = ledger.openTurn.rows;
         const active = window.filter((row) => row.kind === "tool" && row.state === "active");
@@ -222,13 +258,14 @@ export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEF
         const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
         const selected = new Set([...tail, ...voice, ...active, ...pending]);
         const omitted = window.filter((row) => !selected.has(row)).length;
-        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted };
+        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted, ...reported };
     }
     return {
         kind: "idle",
         ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
         entries: entries(pending),
         omitted: 0,
+        ...reported,
     };
 }
 /** Apply the one snapshot policy used by every public observation consumer. */

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

@@ -23,7 +23,7 @@ export type ToolCall = Readonly<{
 }> | Readonly<{
     kind: "fileChange";
     changes: readonly Readonly<{
-        op: "add" | "update" | "delete";
+        op: "add" | "update" | "delete" | "unspecified";
         path: string;
         diffstat?: Readonly<{
             added: number;

package/build/src/akuma/provider.js

@@ -87,7 +87,8 @@ function decodeDiffstat(value) {
 }
 function decodeFileChangeMember(value) {
     const change = object(value);
-    if (change === null || (change.op !== "add" && change.op !== "update" && change.op !== "delete")
+    if (change === null || (change.op !== "add" && change.op !== "update"
+        && change.op !== "delete" && change.op !== "unspecified")
         || typeof change.path !== "string")
         return null;
     const diffstat = decodeDiffstat(change.diffstat);

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

@@ -1,9 +1,12 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { type ProviderAdapter, type Session } from "../../provider.js";
+import { type AcpToolInterpreter, type AcpToolUpdate } from "./events.js";
+export type { AcpToolInterpreter, AcpToolUpdate };
 export type AcpStartInput = Parameters<ProviderAdapter["start"]>[0] | Parameters<NonNullable<ProviderAdapter["resume"]>>[0];
 export type AcpDependencies = Readonly<{
     spawnProcess?: typeof spawnStdioProcess;
+    interpretTool?: AcpToolInterpreter;
 }>;
 export type AcpLiveSession = Readonly<{
     session: Session;
@@ -16,4 +19,3 @@ type AcpLaunch = Readonly<{
     env?: Readonly<Record<string, string>>;
 }>;
 export declare function startAcpSession(launch: AcpLaunch, input: AcpStartInput, dependencies?: AcpDependencies): Promise<AcpLiveSession>;
-export {};

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

@@ -3,7 +3,7 @@ import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
 import { AgentEventChannel, } from "../../provider.js";
-import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate } from "./events.js";
+import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
 function diagnostic(error) {
     if (!(error instanceof Error))
         return String(error);
@@ -46,7 +46,7 @@ async function establishSession(agent, input) {
     await agent.request(acp.methods.agent.session.load, { cwd: input.cwd, mcpServers: [], sessionId });
     return sessionId;
 }
-function createAcpTurn(connection) {
+function createAcpTurn(connection, interpret) {
     const events = new AgentEventChannel();
     let state = EMPTY_ACP_EVENT_STATE;
     let terminal = false;
@@ -55,7 +55,7 @@ function createAcpTurn(connection) {
     const update = (next) => {
         if (terminal)
             return;
-        const mapped = mapAcpUpdate(next, state);
+        const mapped = mapAcpUpdate(next, state, interpret);
         state = mapped.state;
         for (const event of mapped.events)
             events.emit(event);
@@ -138,7 +138,7 @@ export async function startAcpSession(launch, input, dependencies = {}) {
         if (notification.sessionId === sessionId)
             turn.update(notification.update);
     }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
-    turn = createAcpTurn(connection);
+    turn = createAcpTurn(connection, dependencies.interpretTool);
     try {
         sessionId = await abortable(establishSession(connection.agent, input), signal);
         turn.events.emit({ type: "session", coordinate: { sessionId } });

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

@@ -1,14 +1,22 @@
 import type { SessionUpdate } from "@agentclientprotocol/sdk";
-import { type AgentEvent } from "../../provider.js";
+import { type AgentEvent, type ToolCall } from "../../provider.js";
 type OpenBlock = Readonly<{
     type: "assistant" | "thought";
     text: string;
 }> | null;
+export type AcpToolObservation = Readonly<{
+    name: string;
+    call: ToolCall;
+}>;
+export type AcpToolUpdate = Extract<SessionUpdate, {
+    sessionUpdate: "tool_call" | "tool_call_update";
+}>;
+export type AcpToolInterpreter = (update: AcpToolUpdate) => ToolCall | undefined;
 export type AcpEventState = Readonly<{
     answer: string;
     assistantMessageId: string | null;
     open: OpenBlock;
-    tools: ReadonlyMap<string, string>;
+    tools: ReadonlyMap<string, AcpToolObservation>;
 }>;
 type AcpEventMapping = Readonly<{
     events: readonly AgentEvent[];
@@ -16,5 +24,5 @@ type AcpEventMapping = Readonly<{
 }>;
 export declare const EMPTY_ACP_EVENT_STATE: AcpEventState;
 export declare function flushAcpEvents(state: AcpEventState, boundary?: readonly AgentEvent[]): AcpEventMapping;
-export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState): AcpEventMapping;
+export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState, interpret?: AcpToolInterpreter): AcpEventMapping;
 export {};

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

@@ -33,7 +33,82 @@ function appendBlock(state, type, text, messageId) {
         },
     };
 }
-export function mapAcpUpdate(update, previous) {
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1
+        ? value
+        : undefined;
+}
+function otherCall(name) {
+    return { kind: "other", display: name };
+}
+function locationFact(locations) {
+    if (locations === null || locations === undefined)
+        return {};
+    for (const location of locations) {
+        const path = nonblank(location.path);
+        if (path === undefined)
+            continue;
+        const offset = positiveLine(location.line);
+        return offset === undefined ? { path } : { path, offset };
+    }
+    return {};
+}
+function standardCall(update, name) {
+    const location = locationFact(update.locations);
+    if (update.kind === "read") {
+        return location.path === undefined
+            ? otherCall(name)
+            : {
+                kind: "read",
+                path: location.path,
+                ...(location.offset === undefined ? {} : { offset: location.offset }),
+            };
+    }
+    const input = object(update.rawInput);
+    if (update.kind === "execute") {
+        const command = nonblank(input?.command);
+        return command === undefined ? otherCall(name) : { kind: "run", command };
+    }
+    if (update.kind === "search") {
+        const query = nonblank(input?.query);
+        if (query === undefined)
+            return otherCall(name);
+        const path = nonblank(input?.path);
+        const glob = nonblank(input?.glob);
+        const scope = input?.scope;
+        const searchScope = scope === "content" || scope === "files" || scope === "web"
+            ? scope
+            : undefined;
+        return {
+            kind: "search",
+            query,
+            ...(searchScope === undefined ? {} : { scope: searchScope }),
+            ...(path === undefined ? {} : { path }),
+            ...(glob === undefined ? {} : { glob }),
+        };
+    }
+    return otherCall(name);
+}
+function strongest(previous, next) {
+    if (previous === undefined || previous.kind === "other")
+        return next;
+    return next.kind === "other" ? previous : next;
+}
+function observeTool(update, previous, interpret) {
+    const name = nonblank(update.name) ?? nonblank(update.title) ?? previous?.name ?? "ACP tool";
+    const standard = standardCall(update, name);
+    const dialect = standard.kind === "other" ? interpret?.(update) : undefined;
+    return { name, call: strongest(previous?.call, dialect ?? standard) };
+}
+export function mapAcpUpdate(update, previous, interpret) {
     switch (update.sessionUpdate) {
         case "agent_message_chunk":
         case "agent_thought_chunk": {
@@ -47,15 +122,14 @@ export function mapAcpUpdate(update, previous) {
         case "user_message_chunk": return flushAcpEvents(previous);
         case "tool_call":
         case "tool_call_update": {
-            const name = update.title ?? (update.sessionUpdate === "tool_call" ? undefined : previous.tools.get(update.toolCallId)) ?? "ACP tool";
-            const observed = { name, call: { kind: "other", display: name } };
+            const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
                 tools.delete(update.toolCallId);
                 return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
             }
             const started = tools.has(update.toolCallId);
-            tools.set(update.toolCallId, name);
+            tools.set(update.toolCallId, observed);
             return started
                 ? flushAcpEvents({ ...previous, tools })
                 : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);

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

@@ -141,12 +141,63 @@ function fileChangeCall(name, path) {
     }
     return undefined;
 }
+function startedPath(name, value) {
+    if (name === "NotebookEdit")
+        return nonblank(value.notebook_path);
+    return nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+}
+function nonnegativeInt(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function fileChange(op, path, gitDiff) {
+    const diff = object(gitDiff);
+    const added = nonnegativeInt(diff?.additions);
+    const removed = nonnegativeInt(diff?.deletions);
+    const diffstat = added === undefined || removed === undefined ? undefined : { added, removed };
+    return {
+        kind: "fileChange",
+        changes: [{ op, path, ...(diffstat === undefined ? {} : { diffstat }) }],
+    };
+}
+function writeResult(result) {
+    const value = object(result);
+    if (value === undefined || (value.type !== "create" && value.type !== "update"))
+        return undefined;
+    const path = nonblank(value.filePath);
+    if (path === undefined)
+        return undefined;
+    const op = value.type === "create" ? "add" : "update";
+    return fileChange(op, path, value.gitDiff);
+}
+function editResult(result) {
+    const value = object(result);
+    if (value === undefined || value.type === "create" || value.type === "update")
+        return undefined;
+    const path = nonblank(value.filePath);
+    if (path === undefined)
+        return undefined;
+    const status = object(value.gitDiff)?.status;
+    return fileChange(status === "added" ? "add" : "update", path, value.gitDiff);
+}
+function notebookResult(result) {
+    const path = nonblank(object(result)?.notebook_path);
+    return path === undefined
+        ? undefined
+        : { kind: "fileChange", changes: [{ op: "update", path }] };
+}
+function structuredFileChange(name, result) {
+    if (name === "Write")
+        return writeResult(result);
+    if (name === "Edit")
+        return editResult(result);
+    return name === "NotebookEdit" ? notebookResult(result) : undefined;
+}
 function toolCall(name, input) {
     const value = object(input) ?? {};
     const run = runCall(name, value);
     if (run !== undefined)
         return run;
-    const path = nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+    const path = startedPath(name, value);
     return readCall(name, path, value)
         ?? searchCall(name, value)
         ?? fileChangeCall(name, path)
@@ -192,9 +243,17 @@ function toolResultEvents(message, events, state) {
         if (observed === undefined)
             continue;
         state.tools.delete(id);
+        const failed = value.is_error === true;
+        const structured = failed
+            ? undefined
+            : structuredFileChange(observed.name, message.tool_use_result);
         events.emit({
-            type: "tool", phase: "completed", id, name: observed.name, call: observed.call,
-            result: { status: value.is_error === true ? "error" : "ok" },
+            type: "tool",
+            phase: "completed",
+            id,
+            name: observed.name,
+            call: structured ?? observed.call,
+            result: { status: failed ? "error" : "ok" },
         });
     }
 }