@astrosheep/keiyaku 4.1.1 → 4.1.3

package/build/src/akuma/body-supervisor.js

@@ -0,0 +1,89 @@
+import { abortableDelay } from "./abort.js";
+import { heartExists, readHeart } from "./heart/index.js";
+const BODY_CONTROL_OBSERVATION_MS = 100;
+export const CONTROL_RESPONSE_MS = 1_000;
+export class BodySupervisor {
+    paths;
+    bodySequence;
+    leash;
+    signal;
+    controller = new AbortController();
+    finished = new AbortController();
+    observer;
+    waiter;
+    observation;
+    stopping;
+    constructor(paths, bodySequence, leash, observation) {
+        this.paths = paths;
+        this.bodySequence = bodySequence;
+        this.leash = leash;
+        this.signal = this.controller.signal;
+        this.observation = observation;
+        this.observer = this.observe();
+    }
+    static async open(paths, bodySequence, leash) {
+        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+    }
+    get reason() {
+        return this.stopping;
+    }
+    current() {
+        return this.observation;
+    }
+    async recordHung(diagnostic, at) {
+        await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
+    }
+    async refresh() {
+        this.publish(await readHeart(this.paths));
+        return this.observation;
+    }
+    next(after) {
+        if (this.observation !== after)
+            return Promise.resolve(this.observation);
+        return new Promise((resolve) => {
+            this.waiter = resolve;
+        });
+    }
+    cancel(reason) {
+        if (this.stopping !== undefined)
+            return;
+        this.stopping = reason;
+        this.controller.abort(new Error(reason === "control" ? "Akuma Body interrupted by durable control" : "Akuma Heart disappeared"));
+        this.waiter?.(this.observation);
+        this.waiter = undefined;
+    }
+    async close() {
+        this.finished.abort();
+        await this.observer;
+        this.waiter = undefined;
+    }
+    publish(snapshot) {
+        this.observation = snapshot;
+        this.waiter?.(snapshot);
+        this.waiter = undefined;
+    }
+    async observe() {
+        for (;;) {
+            const snapshot = this.observation;
+            if (!(await heartExists(this.paths)))
+                return this.cancel("heart-gone");
+            if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
+                return this.cancel("control");
+            }
+            try {
+                await abortableDelay(BODY_CONTROL_OBSERVATION_MS, this.finished.signal);
+            }
+            catch {
+                return;
+            }
+            try {
+                await this.refresh();
+            }
+            catch (error) {
+                if (await heartExists(this.paths))
+                    throw error;
+                return this.cancel("heart-gone");
+            }
+        }
+    }
+}

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

@@ -4,7 +4,7 @@ import type { ProviderAdapter } from "./provider.js";
 import { type UpstreamExecutionPort, type RequestChildLaunch } from "./request-serve.js";
 import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 export type BodyLaunch = Readonly<{
     paths: AkumaPaths;
     seed?: Omit<Soul, "createdAt">;

package/build/src/akuma/body.js

@@ -1,13 +1,14 @@
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
-import { BodySupervisor, driveTurn, turnRecipe } from "./body-turn.js";
+import { BodySupervisor } from "./body-supervisor.js";
+import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { handoffProcess, spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
 export const LEASH_HELD_EXIT = 75;
-export { CONTROL_RESPONSE_MS } from "./body-turn.js";
+export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
     return isHeartAbsent(error) || error.code === "ENOENT";
 }
@@ -83,8 +84,11 @@ export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url)
         throw new Error("Akuma wake has no born soul");
     const source = bodyModuleUrl.endsWith(".ts");
     const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
+    const argv = source
+        ? [process.execPath, "--import", import.meta.resolve("tsx"), entry, encoded]
+        : [process.execPath, entry, encoded];
     return {
-        argv: source ? [process.execPath, "--import", "tsx", entry, encoded] : [process.execPath, entry, encoded],
+        argv,
         cwd: await launchCwd(launch),
         env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
         log: launch.paths.log,

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

@@ -3,7 +3,7 @@ import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, S
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";

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

@@ -3,7 +3,7 @@ import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingT
 import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
-export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash, watchHeart } from "./storage.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
 export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;

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

@@ -1,5 +1,6 @@
 import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
+export declare function heartSchemaIsCurrent(database: DatabaseSync): boolean;
 export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 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

@@ -11,6 +11,15 @@ export function assertHeartSchemaVersion(database) {
 export function assertLeashSchemaVersion(database) {
     assertSchemaVersion(database, "leash_schema", LEASH_SCHEMA_VERSION);
 }
+export function heartSchemaIsCurrent(database) {
+    try {
+        const row = database.prepare(`SELECT version FROM akuma_schema WHERE singleton = 1`).get();
+        return row?.version === HEART_SCHEMA_VERSION;
+    }
+    catch {
+        return false;
+    }
+}
 export const HEART_SCHEMA = `
   CREATE TABLE IF NOT EXISTS akuma_schema (
     singleton INTEGER PRIMARY KEY CHECK (singleton = 1),

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

@@ -8,6 +8,7 @@ export declare class HeartAbsentError extends Error {
     constructor(path: string, options?: ErrorOptions);
 }
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
+export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 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;

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

@@ -3,7 +3,7 @@ import { watch as watchDirectory } from "node:fs";
 import { lstat } from "node:fs/promises";
 import { basename, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
-import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion } from "./schema.js";
+import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, } from "./schema.js";
 import { deletePauseControl, deleteStopControl, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
 import { insertTellFact } from "./tells.js";
 import { pruneActivityFacts } from "./timeline.js";
@@ -115,6 +115,23 @@ async function openHeart(path, verify = true) {
         throw error;
     }
 }
+export async function classifyHeartSchema(paths) {
+    let database;
+    try {
+        database = await openExistingDatabase(paths.heart);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return "unsupported";
+        throw error;
+    }
+    try {
+        return heartSchemaIsCurrent(database) ? "current" : "unsupported";
+    }
+    finally {
+        database.close();
+    }
+}
 export async function withHeart(paths, body) {
     const database = await openHeart(paths.heart);
     try {

package/build/src/akuma/nuke.js

@@ -2,7 +2,7 @@ import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
 import { CONTROL_RESPONSE_MS } from "./body.js";
-import { HeldAkumaLeash, readHeart, readKill, requestStop } from "./heart/index.js";
+import { HeldAkumaLeash, classifyHeartSchema, readHeart, readKill, requestStop } from "./heart/index.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
 const POLL_MS = 100;
 async function hasAkumaCustody(paths) {
@@ -201,8 +201,11 @@ async function nukeAkumaEntries(world) {
 export async function stopAkuma(world) {
     const entries = await nukeAkumaEntries(world);
     const held = [];
+    let prepared = false;
     try {
         for (const entry of entries) {
+            if ((await classifyHeartSchema(entry.paths)) === "unsupported")
+                continue;
             const snapshot = await readHeart(entry.paths);
             const leash = snapshot.soul !== null && snapshot.latestBody?.end === undefined
                 ? await stopRunningAkuma(entry)
@@ -222,6 +225,7 @@ export async function stopAkuma(world) {
                 throw error;
             }
         }
+        prepared = true;
         return async () => {
             try {
                 await nukeAliases(world);
@@ -236,7 +240,7 @@ export async function stopAkuma(world) {
         };
     }
     finally {
-        if (held.length !== entries.length) {
+        if (!prepared) {
             for (const leash of held.reverse())
                 leash.release();
         }

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

@@ -0,0 +1,17 @@
+import type { ActivitySnapshot, TurnLedger } from "./projection.js";
+import type { HistoryCursor, HistoryPage } from "./projection.js";
+export declare function ordinarySnapshotBudget(ordinaryBudget?: number): Readonly<{
+    tail: number;
+    voice: number;
+}>;
+export declare function selectSnapshot(ledger: TurnLedger, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    budget?: Readonly<{
+        tail: number;
+        voice?: number;
+    }>;
+}>): Readonly<{
+    snapshot: ActivitySnapshot;
+    ordinaryCount: number;
+}>;
+export declare function selectHistory(ledger: TurnLedger, cursor: HistoryCursor): HistoryPage;

package/build/src/akuma/projection-read.js

@@ -0,0 +1,135 @@
+const DEFAULT_TAIL = 3;
+const DEFAULT_VOICE = 3;
+const REPORTED_CHANGE_LIMIT = 5;
+const EMPTY_REPORTED = { reportedChanges: [], reportedChangesOmitted: 0 };
+function assembleEntries(ledger, window, selected) {
+    const windowRows = new Set(window);
+    const result = [];
+    let hidden = 0;
+    const flushGap = () => {
+        if (hidden === 0)
+            return;
+        result.push({ kind: "gap", count: hidden });
+        hidden = 0;
+    };
+    for (const row of ledger.rows) {
+        if (windowRows.has(row) && !selected.has(row)) {
+            hidden += 1;
+            continue;
+        }
+        if (!selected.has(row))
+            continue;
+        flushGap();
+        if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
+            result.push({ kind: "row", row: row });
+        }
+    }
+    flushGap();
+    return result;
+}
+const DEFAULT_ORDINARY = DEFAULT_TAIL + DEFAULT_VOICE;
+export function ordinarySnapshotBudget(ordinaryBudget = DEFAULT_ORDINARY) {
+    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
+    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
+}
+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);
+}
+function isPendingTell(row) {
+    return row.kind === "tell" && row.state === "pending";
+}
+function isToldTell(row) {
+    return row.kind === "tell" && row.state === "told";
+}
+function isActiveTool(row) {
+    return row.kind === "tool" && row.state === "active";
+}
+export function selectSnapshot(ledger, input) {
+    const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
+    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
+        return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
+    const pending = ledger.rows.filter(isPendingTell);
+    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
+    const pins = latestTold === undefined ? pending : [...pending, latestTold];
+    const reported = frontierReportedChanges(ledger);
+    if (ledger.openTurn !== undefined) {
+        const window = ledger.openTurn.rows;
+        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
+        const ordinary = window.filter((row) => !pinSet.has(row));
+        const tailCount = Math.max(0, budget.tail);
+        const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
+        const tailSet = new Set(tail);
+        const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
+        const voiceCandidates = ordinary.filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
+        const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
+        const selected = new Set([...pinSet, ...tail, ...voice]);
+        const omitted = window.filter((row) => !selected.has(row)).length;
+        return {
+            snapshot: {
+                kind: "open",
+                turn: ledger.openTurn.turn,
+                entries: assembleEntries(ledger, window, selected),
+                omitted,
+                ...reported,
+            },
+            ordinaryCount: tail.length + voice.length,
+        };
+    }
+    return {
+        snapshot: {
+            kind: "idle",
+            ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
+            entries: assembleEntries(ledger, [], new Set(pins)),
+            omitted: 0,
+            ...reported,
+        },
+        ordinaryCount: 0,
+    };
+}
+export function selectHistory(ledger, cursor) {
+    const eligible = ledger.rows.filter((row) => cursor.before !== undefined
+        ? row.sequence < cursor.before
+        : cursor.since !== undefined
+            ? row.sequence > cursor.since
+            : true);
+    const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
+    const omitted = Math.max(0, eligible.length - rows.length);
+    const historyLost = cursor.since !== undefined
+        ? ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1
+        : ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0;
+    return {
+        rows,
+        omitted,
+        hasEarlier: cursor.since === undefined && eligible.length > rows.length,
+        hasLater: cursor.since !== undefined && eligible.length > rows.length,
+        historyLost,
+        lowestRetained: ledger.retained.lowestRetained,
+        highest: ledger.retained.highest,
+    };
+}

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

@@ -172,21 +172,4 @@ export type TurnLedger = Readonly<{
 }>;
 /** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
 export declare function projectTurns(facts: readonly TimelineFact[], retained?: RetainedWindow): TurnLedger;
-/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export declare function ordinarySnapshotBudget(ordinaryBudget?: number): Readonly<{
-    tail: number;
-    voice: number;
-}>;
-/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export declare function selectSnapshot(ledger: TurnLedger, input: Readonly<{
-    aperture: "monitoring" | "receipt";
-    budget?: Readonly<{
-        tail: number;
-        voice?: number;
-    }>;
-}>): Readonly<{
-    snapshot: ActivitySnapshot;
-    ordinaryCount: number;
-}>;
-export declare function selectHistory(ledger: TurnLedger, cursor: HistoryCursor): HistoryPage;
-export {};
+export { ordinarySnapshotBudget, selectHistory, selectSnapshot } from "./projection-read.js";

package/build/src/akuma/projection.js

@@ -1,8 +1,4 @@
 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);
@@ -124,6 +120,25 @@ function finishTurn(turn) {
     }
     return { kind: "open", turn: turn.turn, rows: rows };
 }
+function finishLedger(state, retained) {
+    const turns = state.turns.map(finishTurn);
+    const rows = [
+        ...turns.flatMap((turn) => [turn.turn, ...turn.rows, ...(turn.kind === "closed" ? [turn.outcome] : [])]),
+        ...state.tells,
+        ...state.orphanRows,
+        ...state.orphanOutcomes,
+    ].sort((left, right) => left.sequence - right.sequence);
+    const frontier = turns.at(-1);
+    const openTurn = frontier?.kind === "open" ? frontier : undefined;
+    const latestOutcome = rows.findLast((row) => row.kind === "outcome");
+    return {
+        rows,
+        turns,
+        retained,
+        ...(openTurn === undefined ? {} : { openTurn }),
+        ...(latestOutcome === undefined ? {} : { latestOutcome }),
+    };
+}
 /** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
 export function projectTurns(facts, retained = {
     lowestRetained: facts[0]?.sequence ?? null,
@@ -196,155 +211,6 @@ export function projectTurns(facts, retained = {
             projectActivityEvent(state, fact);
         }
     }
-    const turns = state.turns.map(finishTurn);
-    const rows = [
-        ...turns.flatMap((turn) => [turn.turn, ...turn.rows, ...(turn.kind === "closed" ? [turn.outcome] : [])]),
-        ...state.tells,
-        ...state.orphanRows,
-        ...state.orphanOutcomes,
-    ].sort((left, right) => left.sequence - right.sequence);
-    const frontier = turns.at(-1);
-    const openTurn = frontier?.kind === "open" ? frontier : undefined;
-    const latestOutcome = rows.findLast((row) => row.kind === "outcome");
-    return {
-        rows,
-        turns,
-        retained,
-        ...(openTurn === undefined ? {} : { openTurn }),
-        ...(latestOutcome === undefined ? {} : { latestOutcome }),
-    };
-}
-function assembleEntries(ledger, window, selected) {
-    const windowRows = new Set(window);
-    const result = [];
-    let hidden = 0;
-    const flushGap = () => {
-        if (hidden === 0)
-            return;
-        result.push({ kind: "gap", count: hidden });
-        hidden = 0;
-    };
-    for (const row of ledger.rows) {
-        if (windowRows.has(row) && !selected.has(row)) {
-            hidden += 1;
-            continue;
-        }
-        if (!selected.has(row))
-            continue;
-        flushGap();
-        if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
-            result.push({ kind: "row", row: row });
-        }
-    }
-    flushGap();
-    return result;
-}
-const DEFAULT_ORDINARY = DEFAULT_TAIL + DEFAULT_VOICE;
-/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export function ordinarySnapshotBudget(ordinaryBudget = DEFAULT_ORDINARY) {
-    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
-    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
-}
-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);
-}
-function isPendingTell(row) {
-    return row.kind === "tell" && row.state === "pending";
-}
-function isToldTell(row) {
-    return row.kind === "tell" && row.state === "told";
-}
-function isActiveTool(row) {
-    return row.kind === "tool" && row.state === "active";
-}
-/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export function selectSnapshot(ledger, input) {
-    const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
-    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell")) {
-        return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
-    }
-    const pending = ledger.rows.filter(isPendingTell);
-    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
-    const pins = latestTold === undefined ? pending : [...pending, latestTold];
-    const reported = frontierReportedChanges(ledger);
-    if (ledger.openTurn !== undefined) {
-        const window = ledger.openTurn.rows;
-        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
-        const ordinary = window.filter((row) => !pinSet.has(row));
-        const tailCount = Math.max(0, budget.tail);
-        const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
-        const tailSet = new Set(tail);
-        const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
-        const voiceCandidates = ordinary.filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
-        const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
-        const selected = new Set([...pinSet, ...tail, ...voice]);
-        const omitted = window.filter((row) => !selected.has(row)).length;
-        return {
-            snapshot: {
-                kind: "open",
-                turn: ledger.openTurn.turn,
-                entries: assembleEntries(ledger, window, selected),
-                omitted,
-                ...reported,
-            },
-            ordinaryCount: tail.length + voice.length,
-        };
-    }
-    return {
-        snapshot: {
-            kind: "idle",
-            ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
-            entries: assembleEntries(ledger, [], new Set(pins)),
-            omitted: 0,
-            ...reported,
-        },
-        ordinaryCount: 0,
-    };
-}
-export function selectHistory(ledger, cursor) {
-    const eligible = ledger.rows.filter((row) => cursor.before !== undefined
-        ? row.sequence < cursor.before
-        : cursor.since !== undefined
-            ? row.sequence > cursor.since
-            : true);
-    const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
-    const omitted = Math.max(0, eligible.length - rows.length);
-    const historyLost = cursor.since !== undefined
-        ? ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1
-        : ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0;
-    return {
-        rows,
-        omitted,
-        hasEarlier: cursor.since === undefined && eligible.length > rows.length,
-        hasLater: cursor.since !== undefined && eligible.length > rows.length,
-        historyLost,
-        lowestRetained: ledger.retained.lowestRetained,
-        highest: ledger.retained.highest,
-    };
+    return finishLedger(state, retained);
 }
+export { ordinarySnapshotBudget, selectHistory, selectSnapshot } from "./projection-read.js";