@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/akuma/nuke.js

@@ -1,9 +1,10 @@
-import { lstat, readdir, rm } from "node:fs/promises";
+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 { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, } from "./identity.js";
-const POLL_MS = 25;
+import { HeldAkumaLeash, readHeart, readKill, requestStop } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
+const POLL_MS = 100;
 async function hasAkumaCustody(paths) {
     try {
         const value = await lstat(paths.heart);
@@ -25,7 +26,7 @@ async function takeLeashUntil(paths, deadline) {
             return leash;
         if (performance.now() >= deadline)
             return null;
-        await wait(POLL_MS);
+        await wait(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
 async function stopRunningAkuma(entry) {
@@ -36,11 +37,11 @@ async function stopRunningAkuma(entry) {
     try {
         if (request.kind === "already-killed" || request.kind === "already-stopped")
             return leash;
-        if (await readKill(entry.paths, request.body.sequence) !== null)
+        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)
+            if ((await readKill(entry.paths, request.body.sequence)) !== null)
                 return leash;
             throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
         }
@@ -48,7 +49,7 @@ async function stopRunningAkuma(entry) {
             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) {
+        if ((await leash.settleStop(entry.paths, request.body.sequence)) === null) {
             throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
         }
         return leash;
@@ -58,22 +59,112 @@ async function stopRunningAkuma(entry) {
         throw error;
     }
 }
-async function removeRegularFile(path) {
+async function removeKnownRegularFile(path) {
     try {
         const value = await lstat(path);
-        if (value.isFile() && !value.isSymbolicLink())
-            await rm(path, { force: true });
+        if (!value.isFile() || value.isSymbolicLink())
+            throw new Error(`Akuma custody is not a regular file: ${path}`);
+        await rm(path, { force: true });
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
+async function removeEmptyDirectory(path) {
+    try {
+        await rmdir(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT" && error.code !== "ENOTEMPTY")
+            throw error;
+    }
+}
+function isRequestSequenceName(name) {
+    const sequence = Number(name);
+    return /^\d+$/u.test(name) && Number.isSafeInteger(sequence) && String(sequence) === name;
+}
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+function isRequestArtifactName(name) {
+    const match = /^(.*)\.(?:request|receipt)\.json$/u.exec(name);
+    return match !== null && UUID_V4.test(match[1]);
+}
+async function removeKnownRequestFile(path) {
+    try {
+        const value = await lstat(path);
+        if (!value.isFile() || value.isSymbolicLink())
+            return;
+        await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function removeKnownRequestChannel(path) {
+    try {
+        const value = await lstat(path);
+        if (!value.isDirectory() || value.isSymbolicLink())
+            throw new Error(`Akuma custody is not a directory: ${path}`);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    for (const name of await readdir(path)) {
+        if (!isRequestSequenceName(name))
+            continue;
+        const sequenceDir = join(path, name);
+        try {
+            const sequence = await lstat(sequenceDir);
+            if (!sequence.isDirectory() || sequence.isSymbolicLink())
+                continue;
+            for (const child of await readdir(sequenceDir)) {
+                if (isRequestArtifactName(child))
+                    await removeKnownRequestFile(join(sequenceDir, child));
+            }
+            await removeEmptyDirectory(sequenceDir);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    await removeEmptyDirectory(path);
+}
 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);
+    await removeKnownRequestChannel(entry.paths.requests);
+    for (const path of [
+        entry.paths.log,
+        `${entry.paths.heart}-wal`,
+        `${entry.paths.heart}-shm`,
+        `${entry.paths.leash}-wal`,
+        `${entry.paths.leash}-shm`,
+        entry.paths.leash,
+        entry.paths.heart,
+    ]) {
+        await removeKnownRegularFile(path);
+    }
+    await removeEmptyDirectory(entry.paths.directory);
+}
+async function removeEmptyAkumaRunRoot(world) {
+    const runRoot = akumaRunRoot(world);
+    let names;
+    try {
+        names = await readdir(runRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
     }
+    if (names.some((name) => name !== ".gitignore"))
+        return;
+    if (names.includes(".gitignore"))
+        await removeKnownRegularFile(join(runRoot, ".gitignore"));
+    await removeEmptyDirectory(runRoot);
+    await removeEmptyDirectory(dirname(runRoot));
 }
 async function nukeAkumaEntries(world) {
     const runRoot = akumaRunRoot(world);
@@ -136,6 +227,7 @@ export async function stopAkuma(world) {
                 await nukeAliases(world);
                 for (const entry of entries)
                     await removeAkumaEntry(entry);
+                await removeEmptyAkumaRunRoot(world);
             }
             finally {
                 for (const leash of held.reverse())

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,19 +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;
-}>;
-/** Count selected ordinary rows; active tools and pending tells stay outside this total. */
-export declare function ordinarySelectedCount(snapshot: ActivitySnapshot): number;
-/** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export declare function selectSnapshot(ledger: TurnLedger, budget?: Readonly<{
-    tail: number;
-    voice?: number;
-}>): ActivitySnapshot;
-/** Apply the one snapshot policy used by every public observation consumer. */
-export declare function selectActivitySnapshot(facts: readonly TimelineFact[]): ActivitySnapshot;
-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);
@@ -15,12 +11,24 @@ function toolKey(turnSequence, id) {
 }
 function narrationRow(fact, event) {
     if (event.type === "assistant") {
-        return { kind: "said", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: event.text,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            kind: "said",
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            text: event.text,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     if (event.type === "thought" || event.type === "note") {
-        return { kind: event.type, sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: event.text,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            kind: event.type,
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            text: event.text,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     return null;
 }
@@ -43,7 +51,16 @@ function projectToolEvent(rows, running, fact, event, phase) {
     const index = running.get(key);
     const started = index === undefined ? undefined : rows[index];
     if (started?.kind !== "tool") {
-        rows.push({ kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: event.result, ...(event.truncated === true ? { truncated: true } : {}) });
+        rows.push({
+            kind: "tool",
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            name: event.name,
+            call: event.call,
+            state: event.result,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        });
         return;
     }
     const durationMs = duration(started.at, fact.at);
@@ -103,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,
@@ -118,13 +154,25 @@ export function projectTurns(facts, retained = {
     };
     for (const fact of facts) {
         if (fact.kind === "turn-start") {
-            const turn = { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt };
+            const turn = {
+                kind: "turn",
+                sequence: fact.sequence,
+                turnSequence: fact.sequence,
+                bodySequence: fact.bodySequence,
+                at: fact.startedAt,
+            };
             const projected = { phase: "open", turn, rows: [], running: new Map() };
             state.turns.push(projected);
             state.turnsBySequence.set(turn.turnSequence, projected);
         }
         else if (fact.kind === "turn-end") {
-            const outcome = { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome };
+            const outcome = {
+                kind: "outcome",
+                sequence: fact.sequence,
+                turnSequence: fact.turnSequence,
+                at: fact.completedAt,
+                outcome: fact.outcome,
+            };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)
                 state.orphanOutcomes.push(outcome);
@@ -135,7 +183,13 @@ export function projectTurns(facts, retained = {
             }
         }
         else if (fact.kind === "call") {
-            const row = { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body };
+            const row = {
+                kind: "call",
+                sequence: fact.sequence,
+                turnSequence: fact.turnSequence,
+                at: fact.at,
+                text: fact.body,
+            };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)
                 state.orphanRows.push(row);
@@ -143,151 +197,20 @@ export function projectTurns(facts, retained = {
                 turn.rows.push(row);
         }
         else if (fact.kind === "tell") {
-            state.tells.push({ kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries });
+            state.tells.push({
+                kind: "tell",
+                sequence: fact.sequence,
+                at: fact.recordedAt,
+                tellId: fact.id,
+                text: fact.body,
+                state: fact.state,
+                deliveries: fact.deliveries,
+            });
         }
         else {
             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 entries(rows) {
-    return rows.map((row) => ({ kind: "row", row }));
-}
-function openEntries(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 });
-        }
-    }
-    flushGap();
-    return result;
-}
-/** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export function ordinarySnapshotBudget(ordinaryBudget) {
-    const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
-    return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
-}
-/** Count selected ordinary rows; active tools and pending tells stay outside this total. */
-export function ordinarySelectedCount(snapshot) {
-    return snapshot.entries.reduce((count, entry) => {
-        if (entry.kind !== "row")
-            return count;
-        if (entry.row.kind === "tool" && entry.row.state === "active")
-            return count;
-        if (entry.row.kind === "tell" && entry.row.state === "pending")
-            return count;
-        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, ...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");
-        const ordinary = window.filter((row) => !(row.kind === "tool" && row.state === "active"));
-        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([...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, ...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. */
-export function selectActivitySnapshot(facts) {
-    return selectSnapshot(projectTurns(facts));
-}
-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";

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

@@ -59,15 +59,20 @@ export function decodeReadonlyRestraint(value) {
     if (restraint.enforcement === "native") {
         return Object.freeze({ enforcement: "native" });
     }
-    if (restraint.enforcement === "none"
-        && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
+    if (restraint.enforcement === "none" &&
+        typeof restraint.diagnostic === "string" &&
+        restraint.diagnostic.trim().length > 0) {
         return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
     }
     throw new TypeError("readonly restraint must be native or none with a diagnostic");
 }
 function providerKind(value) {
-    return value === "acp" || value === "claude-agent-sdk" || value === "codex-app-server" || value === "grok-build"
-        || value === "opencode-sdk" || value === "pi";
+    return (value === "acp" ||
+        value === "claude-agent-sdk" ||
+        value === "codex-app-server" ||
+        value === "grok-build" ||
+        value === "opencode-sdk" ||
+        value === "pi");
 }
 export function decodeProviderRecipe(input) {
     const value = record(input);
@@ -78,7 +83,8 @@ export function decodeProviderRecipe(input) {
     }
     if (!providerKind(value.kind))
         throw new TypeError("provider execution has unknown kind");
-    if (value.executable !== undefined && (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
+    if (value.executable !== undefined &&
+        (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
         throw new TypeError("provider execution executable must be a nonblank string");
     }
     const config = value.config === undefined ? undefined : record(value.config);