@astrosheep/keiyaku 2.9.13 → 4.0.1

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

@@ -0,0 +1,12 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { TellDeliveryInput, TellFact, TellReceiptInput } from "./facts.js";
+export declare const tellStateSql = "CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND";
+export declare const pendingTellSequencesSql = "SELECT tells.sequence FROM tells WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'";
+export declare const pendingTellProtectionSql = "SELECT d.turn_sequence FROM tell_deliveries d\n  JOIN tells ON tells.id = d.tell_id WHERE CASE\n  WHEN EXISTS (\n    SELECT 1 FROM tell_deliveries d\n    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')\n  ) THEN 'told'\n  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'\n  WHEN EXISTS (\n    SELECT 1 FROM tell_receipts r\n    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence\n    WHERE r.evidence = 'fence' AND d.tell_id = tells.id\n  ) THEN 'told'\n  ELSE 'pending'\nEND = 'pending'";
+export declare function decodeTellAtSequence(database: DatabaseSync, sequence: number): TellFact;
+export declare function insertTellFact(database: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): number;
+export declare function tellFact(database: DatabaseSync, id: string): TellFact | null;
+export declare function insertTellDeliveryFact(database: DatabaseSync, input: TellDeliveryInput): void;
+export declare function insertTellReceiptFact(database: DatabaseSync, input: TellReceiptInput): void;
+export declare function tellIdsForFence(database: DatabaseSync, turnSequence: number, fence: string): readonly string[];
+export declare function pendingTellFacts(database: DatabaseSync): readonly TellFact[];

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

@@ -0,0 +1,79 @@
+export const tellStateSql = `CASE
+  WHEN EXISTS (
+    SELECT 1 FROM tell_deliveries d
+    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')
+  ) THEN 'told'
+  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'
+  WHEN EXISTS (
+    SELECT 1 FROM tell_receipts r
+    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence
+    WHERE r.evidence = 'fence' AND d.tell_id = tells.id
+  ) THEN 'told'
+  ELSE 'pending'
+END`;
+export const pendingTellSequencesSql = `SELECT tells.sequence FROM tells WHERE ${tellStateSql} = 'pending'`;
+export const pendingTellProtectionSql = `SELECT d.turn_sequence FROM tell_deliveries d
+  JOIN tells ON tells.id = d.tell_id WHERE ${tellStateSql} = 'pending'`;
+function tellDeliveries(database, id) {
+    const rows = database.prepare(`SELECT turn_sequence, route, receipt, delivered_at FROM tell_deliveries
+    WHERE tell_id = ? ORDER BY sequence`).all(id);
+    return rows.map((row) => row.receipt == null
+        ? { turnSequence: row.turn_sequence, route: row.route, deliveredAt: row.delivered_at }
+        : { turnSequence: row.turn_sequence, route: row.route, receipt: row.receipt, deliveredAt: row.delivered_at });
+}
+function decodeTellRow(database, row) {
+    return {
+        kind: "tell",
+        sequence: row.sequence,
+        id: row.id,
+        body: row.body,
+        state: row.state,
+        recordedAt: row.recorded_at,
+        deliveries: tellDeliveries(database, row.id),
+    };
+}
+export function decodeTellAtSequence(database, sequence) {
+    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE sequence = ?`).get(sequence);
+    if (row === undefined)
+        throw new Error(`Akuma timeline references missing tell ${sequence}`);
+    return decodeTellRow(database, row);
+}
+export function insertTellFact(database, tell) {
+    const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('tell')").run().lastInsertRowid);
+    database.prepare("INSERT INTO tells(id, sequence, body, recorded_at) VALUES (?, ?, ?, ?)")
+        .run(tell.id, sequence, tell.body, tell.recordedAt);
+    return sequence;
+}
+export function tellFact(database, id) {
+    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE id = ?`).get(id);
+    return row === undefined ? null : decodeTellRow(database, row);
+}
+export function insertTellDeliveryFact(database, input) {
+    const result = database.prepare(`INSERT OR IGNORE INTO tell_deliveries(
+    tell_id, route, turn_sequence, fence, receipt, delivered_at
+  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.tellId, input.route, input.turnSequence, input.fence, input.route === "live" ? input.receipt : null, input.deliveredAt);
+    const row = database.prepare(`SELECT route, receipt FROM tell_deliveries
+    WHERE tell_id = ? AND turn_sequence = ? AND fence = ?`)
+        .get(input.tellId, input.turnSequence, input.fence);
+    if (row === undefined || (result.changes === 0
+        && (row.route !== input.route || row.receipt !== (input.route === "live" ? input.receipt : null)))) {
+        throw new Error(`tell delivery ${input.tellId} has conflicting evidence`);
+    }
+}
+export function insertTellReceiptFact(database, input) {
+    database.prepare(`INSERT OR IGNORE INTO tell_receipts(
+    evidence, tell_id, turn_sequence, fence, kind, received_at
+  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.evidence, input.evidence === "exact" ? input.tellId : null, input.evidence === "fence" ? input.turnSequence : null, input.evidence === "fence" ? input.fence : null, input.kind, input.receivedAt);
+}
+export function tellIdsForFence(database, turnSequence, fence) {
+    return database.prepare(`SELECT tell_id FROM tell_deliveries
+    WHERE turn_sequence = ? AND fence = ? ORDER BY sequence`)
+        .all(turnSequence, fence).map((row) => row.tell_id);
+}
+export function pendingTellFacts(database) {
+    const rows = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
+    WHERE ${tellStateSql} = 'pending' ORDER BY sequence`).all();
+    return rows.map((row) => decodeTellRow(database, row));
+}

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

@@ -0,0 +1,15 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { CallFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
+import { type ActivityFact } from "./rows.js";
+export type TimelineFact = TurnStartFact | CallFact | ActivityFact | TellFact | TurnEndFact;
+export type ActivityFactSlice = Readonly<{
+    rows: readonly TimelineFact[];
+    lowestRetained: number | null;
+    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;

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

@@ -0,0 +1,86 @@
+import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
+import { decodeTellAtSequence, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
+export function pruneActivityFacts(database, limit) {
+    const count = database.prepare("SELECT COUNT(*) AS count FROM timeline").get();
+    if (count.count <= limit + 500)
+        return;
+    const cutoff = database.prepare(`SELECT sequence FROM timeline ORDER BY sequence DESC LIMIT 1 OFFSET ?`)
+        .get(limit - 1);
+    if (cutoff === undefined)
+        return;
+    database.prepare(`WITH protected_turns(sequence) AS (
+      SELECT sequence FROM turns WHERE end_sequence IS NULL
+      UNION SELECT turn_sequence FROM calls WHERE sequence >= ?
+      UNION SELECT turn_sequence FROM activity WHERE sequence >= ?
+      UNION SELECT sequence FROM turns WHERE end_sequence >= ?
+      UNION ${pendingTellProtectionSql}
+    ), protected(sequence) AS (
+      SELECT sequence FROM protected_turns
+      UNION SELECT sequence FROM calls WHERE turn_sequence IN (SELECT sequence FROM protected_turns)
+      UNION SELECT end_sequence FROM turns WHERE sequence IN (SELECT sequence FROM protected_turns) AND end_sequence IS NOT NULL
+      UNION ${pendingTellSequencesSql}
+    )
+    DELETE FROM timeline WHERE sequence < ? AND sequence NOT IN protected`)
+        .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
+}
+function turn(database, sequence) {
+    const row = database.prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
+    history_id, session_json, answer, diagnostic, completed_at FROM turns WHERE sequence = ?`)
+        .get(sequence);
+    if (row === undefined)
+        throw new Error(`Akuma timeline references missing Turn ${sequence}`);
+    return decodeTurnRow(row);
+}
+function turnStart(database, sequence) {
+    const row = database.prepare("SELECT sequence, body_sequence, started_at FROM turns WHERE sequence = ?")
+        .get(sequence);
+    if (row === undefined)
+        throw new Error(`Akuma timeline references missing Turn ${sequence}`);
+    return { kind: "turn-start", sequence: row.sequence, bodySequence: row.body_sequence, startedAt: row.started_at };
+}
+function decodeTimelineRow(database, row) {
+    if (row.kind === "turn-start")
+        return turnStart(database, row.sequence);
+    if (row.kind === "turn-end") {
+        const source = database.prepare("SELECT sequence FROM turns WHERE end_sequence = ?").get(row.sequence);
+        const fact = source === undefined ? undefined : turn(database, source.sequence).end;
+        if (fact === undefined)
+            throw new Error(`Akuma timeline references missing Turn end ${row.sequence}`);
+        return fact;
+    }
+    if (row.kind === "call") {
+        const value = database.prepare("SELECT sequence, turn_sequence, body, at FROM calls WHERE sequence = ?")
+            .get(row.sequence);
+        if (value === undefined)
+            throw new Error(`Akuma timeline references missing call ${row.sequence}`);
+        return decodeCallRow(value);
+    }
+    if (row.kind === "activity") {
+        const value = database.prepare("SELECT sequence, turn_sequence, event_json, at FROM activity WHERE sequence = ?")
+            .get(row.sequence);
+        if (value === undefined)
+            throw new Error(`Akuma timeline references missing activity ${row.sequence}`);
+        return decodeActivityRow(value);
+    }
+    return decodeTellAtSequence(database, row.sequence);
+}
+export function activityFactSlice(database, input) {
+    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 };
+}

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

@@ -0,0 +1,46 @@
+declare const AKU_ID: unique symbol;
+export type AkuId = string & {
+    readonly [AKU_ID]: true;
+};
+export type AkumaPaths = Readonly<{
+    directory: string;
+    heart: string;
+    leash: string;
+    log: string;
+}>;
+export type AllocatedAkuma = Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+    paths: AkumaPaths;
+}>;
+export declare function archetypeName(value: string): string;
+export declare function akuId(input: Readonly<{
+    archetype: string;
+    suffix: string;
+}>): AkuId;
+export declare function parseAkuId(value: string): Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+}>;
+export declare function akumaRunRoot(worldRoot: string): string;
+export declare function akumaPaths(input: Readonly<{
+    runRoot: string;
+    archetype: string;
+    suffix: string;
+}>): AkumaPaths;
+export declare function akuIdFromDirectoryName(name: string): Readonly<{
+    id: AkuId;
+    archetype: string;
+    suffix: string;
+}>;
+export declare function ensureAkumaRunRoot(worldRoot: string): string;
+export declare function allocateAkumaDirectory(input: Readonly<{
+    worldRoot: string;
+    archetype: string;
+    draw?: () => string;
+}>): AllocatedAkuma;
+export declare function pathsForAkuId(worldRoot: string, id: AkuId): AkumaPaths;
+export declare function worldRootForAkumaPaths(paths: AkumaPaths): string;
+export {};

package/build/src/akuma/identity.js

@@ -0,0 +1,89 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
+import { normalizeIdentityStem } from "../identity/normalize.js";
+const HEX8 = /^[0-9a-f]{8}$/u;
+export function archetypeName(value) {
+    if (value.length === 0 || normalizeIdentityStem({ source: value }) !== value) {
+        throw new TypeError("Akuma archetype must be one normalized human identity segment");
+    }
+    return value;
+}
+function suffixSegment(value) {
+    if (!HEX8.test(value))
+        throw new TypeError("Akuma suffix must be lower hex8");
+    return value;
+}
+export function akuId(input) {
+    return identityCoordinate({
+        family: "aku",
+        segments: [archetypeName(input.archetype), suffixSegment(input.suffix)],
+    });
+}
+export function parseAkuId(value) {
+    const segments = identitySegments({ family: "aku", value });
+    if (segments.length !== 2)
+        throw new TypeError("Akuma identity must be aku/<archetype>/<hex8>");
+    const archetype = archetypeName(segments[0]);
+    const suffix = suffixSegment(segments[1]);
+    return { id: akuId({ archetype, suffix }), archetype, suffix };
+}
+export function akumaRunRoot(worldRoot) {
+    return join(worldRoot, ".keiyaku", "akuma", "run");
+}
+export function akumaPaths(input) {
+    const directory = join(input.runRoot, `${archetypeName(input.archetype)}-${suffixSegment(input.suffix)}`);
+    return {
+        directory,
+        heart: join(directory, "heart.db"),
+        leash: join(directory, "leash.db"),
+        log: join(directory, "stdio.log"),
+    };
+}
+export function akuIdFromDirectoryName(name) {
+    if (name.length < 10 || name.at(-9) !== "-")
+        throw new Error(`invalid Akuma run directory ${name}`);
+    const archetype = name.slice(0, -9);
+    const suffix = name.slice(-8);
+    return { id: akuId({ archetype, suffix }), archetype, suffix };
+}
+export function ensureAkumaRunRoot(worldRoot) {
+    const runRoot = akumaRunRoot(worldRoot);
+    mkdirSync(runRoot, { recursive: true });
+    try {
+        writeFileSync(join(runRoot, ".gitignore"), "*\n", { flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    return runRoot;
+}
+export function allocateAkumaDirectory(input) {
+    const archetype = archetypeName(input.archetype);
+    const runRoot = ensureAkumaRunRoot(input.worldRoot);
+    for (;;) {
+        const suffix = suffixSegment(input.draw?.() ?? randomBytes(4).toString("hex"));
+        const paths = akumaPaths({ runRoot, archetype, suffix });
+        try {
+            mkdirSync(paths.directory);
+            return { id: akuId({ archetype, suffix }), archetype, suffix, paths };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+    }
+}
+export function pathsForAkuId(worldRoot, id) {
+    const parsed = parseAkuId(id);
+    return akumaPaths({ runRoot: akumaRunRoot(worldRoot), archetype: parsed.archetype, suffix: parsed.suffix });
+}
+export function worldRootForAkumaPaths(paths) {
+    const runRoot = dirname(paths.directory);
+    const worldRoot = dirname(dirname(dirname(runRoot)));
+    if (akumaRunRoot(worldRoot) !== runRoot)
+        throw new Error("Akuma paths are outside the run topology");
+    return worldRoot;
+}

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

@@ -0,0 +1,9 @@
+export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export type { WorldRoot } from "../world.js";
+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 { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
+export type { AkuId } from "./identity.js";
+export type { Confinement, KillEvidence, ProviderOptions, ResumeCoordinate, TurnFact, } from "./heart/index.js";

package/build/src/akuma/index.js

@@ -0,0 +1,3 @@
+export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
+export { AkumaBodyRequestError } from "./requests.js";

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

@@ -0,0 +1,97 @@
+import { type ToolCall, type ToolResult } from "./provider.js";
+import type { ActivitySlice, TellDelivery, TellFact, TimelineFact, TurnEndFact } from "./heart/index.js";
+export type ActivityRow = Readonly<{
+    kind: "turn";
+    sequence: number;
+    turnSequence: number;
+    bodySequence: number;
+    at: string;
+}> | Readonly<{
+    kind: "call";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+}> | Readonly<{
+    kind: "said";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "thought";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "tool";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    completedAt?: string;
+    durationMs?: number;
+    name: string;
+    call: ToolCall;
+    state: "running" | ToolResult;
+    truncated?: true;
+}> | Readonly<{
+    kind: "note";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "tell";
+    sequence: number;
+    at: string;
+    tellId: string;
+    text: string;
+    state: TellFact["state"];
+    deliveries: readonly TellDelivery[];
+}> | Readonly<{
+    kind: "outcome";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    outcome: TurnEndFact["outcome"];
+}>;
+export type ActivitySnapshot = Readonly<{
+    entries: readonly ActivitySnapshotEntry[];
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+export type ActivitySnapshotEntry = Readonly<{
+    kind: "row";
+    row: ActivityRow;
+}> | Readonly<{
+    kind: "gap";
+    count: number;
+}>;
+export type ActivitySnapshotProfile = "status" | "feedback";
+export type ActivityHistory = Readonly<{
+    rows: readonly ActivityRow[];
+    omitted: number;
+    hasEarlier: boolean;
+    hasLater: boolean;
+    historyLost: boolean;
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+/** Project the complete retained fact window in persisted timeline order. */
+export declare function projectTimeline(facts: readonly TimelineFact[]): readonly ActivityRow[];
+/** Apply the bounded snapshot policy after semantic projection. */
+export declare function selectActivitySnapshot(facts: readonly TimelineFact[], input?: Readonly<{
+    lowestRetained?: number | null;
+    highest?: number | null;
+    profile?: ActivitySnapshotProfile;
+}>): ActivitySnapshot;
+/** Apply cursor and limit to the one semantic timeline projection. */
+export declare function projectActivityHistory(slice: ActivitySlice, input: Readonly<{
+    before?: number;
+    since?: number;
+    limit: number;
+}>): ActivityHistory;

package/build/src/akuma/projection.js

@@ -0,0 +1,145 @@
+import { decodeAgentEvent } from "./provider.js";
+const TAIL_LIMIT = 3;
+const VOICE_LIMIT = 5;
+function duration(startedAt, completedAt) {
+    const start = Date.parse(startedAt);
+    const end = Date.parse(completedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        return undefined;
+    return end - start;
+}
+function toolKey(turnSequence, id) {
+    return `${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 } : {}) };
+    }
+    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 null;
+}
+/** Project the complete retained fact window in persisted timeline order. */
+export function projectTimeline(facts) {
+    const state = { rows: [], running: new Map() };
+    for (const fact of facts) {
+        if (fact.kind === "turn-start")
+            state.rows.push({ settled: false, row: { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt } });
+        else if (fact.kind === "turn-end")
+            state.rows.push({ settled: true, row: { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome } });
+        else if (fact.kind === "call")
+            state.rows.push({ settled: true, row: { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body } });
+        else if (fact.kind === "tell")
+            state.rows.push({ settled: fact.state !== "pending", row: { kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries } });
+        else
+            projectActivityEvent(state, fact);
+    }
+    return state.rows.map((entry) => entry.row);
+}
+function projectActivityEvent(state, fact) {
+    const event = decodeAgentEvent(fact.event);
+    const narration = narrationRow(fact, event);
+    if (narration !== null) {
+        state.rows.push({ settled: true, row: narration });
+        return;
+    }
+    if (event.type !== "tool")
+        return;
+    const key = toolKey(fact.turnSequence, event.id);
+    if (event.phase === "started") {
+        state.running.set(key, state.rows.length);
+        state.rows.push({ settled: false, row: { kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: "running", ...(event.truncated === true ? { truncated: true } : {}) } });
+        return;
+    }
+    const index = state.running.get(key);
+    const started = index === undefined ? undefined : state.rows[index]?.row;
+    if (started?.kind !== "tool") {
+        state.rows.push({ settled: true, row: {
+                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 startedAt = started.at;
+    const durationMs = duration(startedAt, fact.at);
+    const completed = {
+        kind: "tool", sequence: started.sequence, turnSequence: fact.turnSequence, at: startedAt,
+        completedAt: fact.at, ...(durationMs === undefined ? {} : { durationMs }),
+        name: event.name, call: event.call, state: event.result,
+        ...(started?.kind === "tool" && started.truncated === true || event.truncated === true ? { truncated: true } : {}),
+    };
+    state.rows[index] = { settled: true, row: completed };
+    state.running.delete(key);
+}
+function pinned(row, latestOutcome, openTurn) {
+    return row === latestOutcome
+        || (row.kind === "turn" && row.turnSequence === openTurn)
+        || (row.kind === "call" && row.turnSequence === openTurn)
+        || (row.kind === "tool" && row.state === "running")
+        || (row.kind === "tell" && row.state === "pending");
+}
+/** Apply the bounded snapshot policy after semantic projection. */
+export function selectActivitySnapshot(facts, input = {}) {
+    const projected = projectTimeline(facts);
+    const ended = new Set(projected.filter((row) => row.kind === "outcome").map((row) => row.turnSequence));
+    const openTurn = projected.findLast((row) => row.kind === "turn" && !ended.has(row.turnSequence));
+    const latestOutcome = projected.findLast((row) => row.kind === "outcome");
+    const ordinary = projected.filter((row) => !pinned(row, latestOutcome, openTurn?.turnSequence));
+    const selected = new Set(ordinary.slice(-TAIL_LIMIT));
+    if ((input.profile ?? "status") === "status") {
+        for (const row of ordinary.filter((value) => value.kind === "said" || value.kind === "thought").slice(-VOICE_LIMIT)) {
+            selected.add(row);
+        }
+    }
+    for (const row of projected)
+        if (pinned(row, latestOutcome, openTurn?.turnSequence))
+            selected.add(row);
+    const entries = [];
+    let hidden = [];
+    const flush = () => {
+        if (hidden.length === 1)
+            entries.push({ kind: "row", row: hidden[0] });
+        else if (hidden.length > 1)
+            entries.push({ kind: "gap", count: hidden.length });
+        hidden = [];
+    };
+    for (const row of projected) {
+        if (!selected.has(row))
+            hidden.push(row);
+        else {
+            flush();
+            entries.push({ kind: "row", row });
+        }
+    }
+    flush();
+    return {
+        entries,
+        lowestRetained: input.lowestRetained ?? (facts[0]?.sequence ?? null),
+        highest: input.highest ?? (facts.at(-1)?.sequence ?? null),
+    };
+}
+/** Apply cursor and limit to the one semantic timeline projection. */
+export function projectActivityHistory(slice, input) {
+    const projected = projectTimeline(slice.rows);
+    const eligible = projected.filter((row) => input.before !== undefined
+        ? row.sequence < input.before
+        : input.since !== undefined ? row.sequence > input.since : true);
+    const rows = input.since !== undefined ? eligible.slice(0, input.limit) : eligible.slice(-input.limit);
+    const forwardHistoryLost = input.since !== undefined
+        && slice.rows[0] !== undefined
+        && slice.rows[0].sequence > input.since + 1;
+    return {
+        rows,
+        omitted: Math.max(0, eligible.length - rows.length),
+        hasEarlier: input.since === undefined && eligible.length > rows.length,
+        hasLater: input.since !== undefined && eligible.length > rows.length,
+        historyLost: forwardHistoryLost || (input.since === undefined && eligible.length === rows.length
+            && slice.lowestRetained !== null && slice.lowestRetained > 1),
+        lowestRetained: slice.lowestRetained,
+        highest: slice.highest,
+    };
+}