spawnfile 0.1.17 → 0.1.19

package/dist/compiler/training/rewind/moltnetSchemas.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { instantNanos } from "./instant.js";
+const text = z.string();
+const id = text.min(1);
+export const moltnetInstantSchema = text.refine((value) => {
+    try {
+        instantNanos(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "Expected an RFC3339 instant with at most nanosecond precision");
+const instant = moltnetInstantSchema;
+const strings = z.array(text);
+// Moltnet validates Actor.ID and Part.Kind, but Actor.Type is an unvalidated Go string.
+// Accept its zero value as stored; never fill or normalize native payload fields.
+const actor = z.object({ type: text, id, name: text.optional(), network_id: text.optional(),
+    fqid: text.optional(), credential_bound: z.boolean().optional() }).strict();
+const target = z.object({ kind: z.enum(["room", "thread", "dm"]), room_id: text.optional(),
+    thread_id: text.optional(), parent_message_id: text.optional(), dm_id: text.optional(),
+    participant_ids: strings.optional() }).strict();
+const part = z.object({ kind: id, text: text.optional(), media_type: text.optional(),
+    url: text.optional(), filename: text.optional(), data: z.record(text, z.unknown()).optional() }).strict();
+export const moltnetMessageSchema = z.object({
+    id, network_id: text, origin: z.object({ network_id: text, message_id: text,
+        received_via: text.optional() }).strict().optional(), target, from: actor,
+    parts: z.array(part).nullable(), mentions: strings.nullable().optional(), created_at: instant
+}).strict();
+export const moltnetRoomSchema = z.object({
+    id, network_id: text.optional(), fqid: text.optional(), name: text,
+    members: strings.nullable().optional(), visibility: text.optional(), write_policy: text.optional(),
+    federation: z.union([z.enum(["all", "none"]), strings]).nullable().optional(),
+    access: z.object({ can_read: z.boolean(), can_write: z.boolean(), reason: text.optional() }).strict().optional(),
+    created_at: instant
+}).strict();
+export const moltnetThreadSchema = z.object({
+    id, network_id: text.optional(), fqid: text.optional(), room_id: id,
+    parent_message_id: text.optional(), message_count: z.number().int().nonnegative(),
+    last_message_at: instant.optional()
+}).strict();
+const direct = z.object({ id, network_id: text.optional(), fqid: text.optional(),
+    participant_ids: strings.optional(), message_count: z.number().int().nonnegative(),
+    last_message_at: instant.optional() }).strict();
+const agentEvent = z.object({ agent_id: id, network_id: text.optional(), fqid: text.optional(),
+    name: text.optional(), message_id: text.optional(), reason: text.optional(), target: target.optional(),
+    error: text.optional(), attempts: z.number().int().optional(), classification: text.optional() }).strict();
+const pairing = z.object({ id, remote_network_id: text, remote_network_name: text.optional(),
+    remote_base_url: text.optional(), status: text.optional(), token: text.optional(),
+    relay: z.object({ url: text, room: text.optional(), token: text.optional() }).strict().optional(),
+    diagnostics: z.object({ checked_at: instant.optional(), remote_version: text.optional(),
+        remote_network_id: text.optional(), remote_protocols: z.object({
+            http: strings.optional(), attach: strings.optional(), pair: strings.optional()
+        }).strict().optional(), reason: text.optional(), message: text.optional() }).strict().optional()
+}).strict();
+// The delivery store persists Event.Type without validation as well.
+export const moltnetEventSchema = z.object({ id, type: text, network_id: text,
+    agent: agentEvent.optional(), message: moltnetMessageSchema.optional(), room: moltnetRoomSchema.optional(),
+    thread: moltnetThreadSchema.optional(), dm: direct.optional(), pairing: pairing.optional(),
+    replay_gap: z.object({ requested_event_id: text.optional(), oldest_event_id: text.optional(),
+        newest_event_id: text.optional() }).strict().optional(), created_at: instant
+}).strict();
+const registration = z.object({ network_id: text, agent_id: id, actor_uid: text, actor_uri: text,
+    display_name: text.optional(), credential_key: text.optional(), created_at: instant.optional(),
+    updated_at: instant.optional() }).strict();
+const map = (value) => z.record(text, value).nullable().transform((v) => v ?? {});
+const messages = map(z.array(moltnetMessageSchema).nullable().transform((v) => v ?? []));
+export const moltnetSnapshotSchema = z.object({
+    rooms: map(moltnetRoomSchema), removed_rooms: map(instant).optional().default({}),
+    room_messages: messages, threads: map(moltnetThreadSchema), thread_messages: messages,
+    direct_messages: messages, direct_members: map(map(z.object({}).strict())),
+    agents: map(registration).optional().default({}),
+    attachment_delivery_events: z.array(moltnetEventSchema).nullable().optional().transform((v) => v ?? []),
+    attachment_delivery_cursors: map(z.number().int().nonnegative()).optional().default({})
+}).strict();

package/dist/compiler/training/rewind/moltnetSqlite.d.ts

@@ -0,0 +1,31 @@
+import { type MoltnetInspection, type MoltnetMessage } from "./moltnetSchemas.js";
+/** Mutates only a caller-created COPY. secure_delete and VACUUM remove future content from free pages. */
+export declare const rewindMoltnetSqlite: (file: string, at: string) => Promise<MoltnetMessage[]>;
+/** Reopens on-disk SQLite read-only; no materializer state or cut helper supplies the verdict. */
+export interface MoltnetMessageFilter {
+    /** Room id, including messages addressed to threads in that room. */
+    room?: string;
+    sender?: string;
+}
+export interface MoltnetSqliteInspection extends MoltnetInspection {
+    /** Filtered messages ordered by stored created_at TEXT, then id, like Moltnet room history. */
+    orderedMessages: Array<MoltnetMessage & {
+        /** Store-local SQLite rowid (append order), before filtering; may contain gaps. */
+        appendIndex: number;
+    }>;
+    /** All stored registrations, independent of message filters; no credential material. */
+    registrations: Array<{
+        agentId: string;
+        networkId: string;
+        actorUid: string;
+    }>;
+    /** Active rooms only, with sorted member IDs. Labels and policies remain caller-owned. */
+    rooms: Array<{
+        id: string;
+        networkId: string | undefined;
+        memberIds: string[];
+    }>;
+    /** IDs whose stored credential is not the stable token:<agent-id> placeholder. Not secret values. */
+    nonCanonicalCredentialAgentIds: string[];
+}
+export declare const inspectMoltnetSqlite: (file: string, at: string, filter?: MoltnetMessageFilter) => Promise<MoltnetSqliteInspection>;

package/dist/compiler/training/rewind/moltnetSqlite.js

@@ -0,0 +1,192 @@
+import { lstat, rm } from "node:fs/promises";
+import { compareInstants } from "./instant.js";
+import { inspectMoltnetEvent, latestMoltnetMessage, moltnetMessages, rewindMoltnetJson } from "./moltnetJson.js";
+import { readMoltnetSqlite, readMoltnetSqliteMigrations, sqliteInteger, sqliteText, sqliteJson } from "./moltnetSqliteData.js";
+import { moltnetEventSchema } from "./moltnetSchemas.js";
+const openSqlite = async (file, readOnly = false) => {
+    let sqlite;
+    try {
+        sqlite = await import("node:sqlite");
+    }
+    catch {
+        throw new Error("Moltnet SQLite rewind requires node:sqlite (supported Node >=22.19); this Node runtime does not expose it");
+    }
+    return new sqlite.DatabaseSync(file, { readOnly, enableForeignKeyConstraints: false, allowExtension: false });
+};
+/** Mutates only a caller-created COPY. secure_delete and VACUUM remove future content from free pages. */
+export const rewindMoltnetSqlite = async (file, at) => {
+    const database = await openSqlite(file);
+    try {
+        const source = readMoltnetSqlite(database), cut = rewindMoltnetJson(source, at);
+        const messages = moltnetMessages(cut), keepMessages = new Set(messages.map((message) => message.id));
+        const eventRows = database.prepare("SELECT * FROM attachment_delivery_events ORDER BY seq").all();
+        const keepEvents = new Set(cut.attachment_delivery_events.map((event) => event.id));
+        // The database column and the embedded event each carry an instant; both must pass the cut.
+        const remainingEvents = eventRows.filter((row) => keepEvents.has(sqliteText(row, "event_id"))
+            && compareInstants(sqliteText(row, "created_at"), at) <= 0);
+        const remainingSeq = new Set(remainingEvents.map((row) => sqliteInteger(row, "seq")));
+        database.exec("PRAGMA secure_delete=ON; PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
+        try {
+            for (const [id, agent] of Object.entries(source.agents)) {
+                if (!cut.agents[id]) {
+                    database.prepare("DELETE FROM agents WHERE agent_id = ?").run(id);
+                    database.prepare("DELETE FROM room_members WHERE member_id = ?").run(id);
+                    database.prepare("DELETE FROM dm_participants WHERE participant_id = ?").run(id);
+                    database.prepare("DELETE FROM attachment_delivery_cursors WHERE agent_id = ?").run(id);
+                }
+                else if (agent.updated_at !== cut.agents[id].updated_at) {
+                    database.prepare("UPDATE agents SET updated_at = ? WHERE agent_id = ?").run(cut.agents[id].updated_at, id);
+                }
+            }
+            for (const row of readMoltnetSqliteMigrations(database)) {
+                if (compareInstants(sqliteText(row, "applied_at"), at) > 0) {
+                    database.prepare("UPDATE schema_migrations SET applied_at = ? WHERE version = ?").run(at, row.version);
+                }
+            }
+            const dropMessage = database.prepare("DELETE FROM messages WHERE id = ?");
+            for (const message of moltnetMessages(source))
+                if (!keepMessages.has(message.id))
+                    dropMessage.run(message.id);
+            const dropRoom = database.prepare("DELETE FROM rooms WHERE id = ?"), restoreRoom = database.prepare("UPDATE rooms SET deleted_at = NULL WHERE id = ?");
+            for (const id of Object.keys(source.rooms)) {
+                if (!cut.rooms[id])
+                    dropRoom.run(id);
+                else if (source.removed_rooms[id] && !cut.removed_rooms[id])
+                    restoreRoom.run(id);
+            }
+            database.exec("DELETE FROM room_members WHERE room_id NOT IN (SELECT id FROM rooms)");
+            const dropThread = database.prepare("DELETE FROM threads WHERE id = ?");
+            const updateThread = database.prepare("UPDATE threads SET message_count = ?, last_message_at = ? WHERE id = ?");
+            for (const id of Object.keys(source.threads)) {
+                const thread = cut.threads[id];
+                if (!thread)
+                    dropThread.run(id);
+                else
+                    updateThread.run(thread.message_count, thread.last_message_at, id);
+            }
+            const dropDm = database.prepare("DELETE FROM dm_conversations WHERE dm_id = ?");
+            const updateDm = database.prepare("UPDATE dm_conversations SET message_count = ?, last_message_at = ? WHERE dm_id = ?");
+            for (const row of database.prepare("SELECT dm_id FROM dm_conversations").all()) {
+                const id = sqliteText(row, "dm_id"), retained = cut.direct_messages[id] ?? [];
+                if (!retained.length)
+                    dropDm.run(id);
+                else
+                    updateDm.run(retained.length, latestMoltnetMessage(retained).created_at, id);
+            }
+            database.exec("DELETE FROM dm_participants WHERE dm_id NOT IN (SELECT dm_id FROM dm_conversations)");
+            database.exec("DELETE FROM artifacts WHERE message_id NOT IN (SELECT id FROM messages)");
+            const dropArtifact = database.prepare("DELETE FROM artifacts WHERE id = ?");
+            for (const row of database.prepare("SELECT id, created_at FROM artifacts").all()) {
+                if (compareInstants(sqliteText(row, "created_at"), at) > 0)
+                    dropArtifact.run(sqliteText(row, "id"));
+            }
+            const dropEvent = database.prepare("DELETE FROM attachment_delivery_events WHERE seq = ?");
+            for (const row of eventRows)
+                if (!remainingSeq.has(sqliteInteger(row, "seq")))
+                    dropEvent.run(sqliteInteger(row, "seq"));
+            const updateCursor = database.prepare("UPDATE attachment_delivery_cursors SET event_seq = ?, updated_at = ? WHERE agent_id = ?");
+            for (const row of database.prepare("SELECT * FROM attachment_delivery_cursors").all()) {
+                const cursor = sqliteInteger(row, "event_seq");
+                const clamped = remainingEvents.reduce((value, event) => {
+                    const seq = sqliteInteger(event, "seq");
+                    return seq <= cursor ? Math.max(value, seq) : value;
+                }, 0);
+                const updated = sqliteText(row, "updated_at");
+                updateCursor.run(clamped, compareInstants(updated, at) > 0 ? at : updated, sqliteText(row, "agent_id"));
+            }
+            const hasSequence = database.prepare("SELECT name FROM sqlite_schema WHERE name = 'sqlite_sequence'").get();
+            if (hasSequence)
+                database.prepare("UPDATE sqlite_sequence SET seq = ? WHERE name = 'attachment_delivery_events'")
+                    .run(remainingEvents.reduce((value, row) => Math.max(value, sqliteInteger(row, "seq")), 0));
+            database.exec("COMMIT");
+        }
+        catch (error) {
+            database.exec("ROLLBACK");
+            throw error;
+        }
+        database.exec("PRAGMA wal_checkpoint(TRUNCATE); PRAGMA journal_mode=DELETE; VACUUM");
+        if (database.prepare("PRAGMA integrity_check").get()?.integrity_check !== "ok")
+            throw new Error("Rewound Moltnet SQLite integrity check failed");
+        return messages;
+    }
+    finally {
+        database.close();
+        for (const suffix of ["-wal", "-shm", "-journal"])
+            await rm(`${file}${suffix}`, { force: true });
+    }
+};
+export const inspectMoltnetSqlite = async (file, at, filter = {}) => {
+    // Validate even empty stores; findings always audit the entire store, independent of filters.
+    compareInstants(at, at);
+    for (const suffix of ["-wal", "-shm", "-journal"]) {
+        const entry = await lstat(`${file}${suffix}`).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        // The materialized database is checkpointed. Refuse sidecars before SQLite can recover or touch them.
+        if (entry)
+            return { messages: 0, events: 0, orderedMessages: [], registrations: [], rooms: [], nonCanonicalCredentialAgentIds: [], findings: [{ class: "moltnet-event", path: `${file}${suffix}`,
+                        detail: "Materialized Moltnet SQLite has an uninspected journal/WAL sidecar" }] };
+    }
+    const database = await openSqlite(file, true);
+    try {
+        const snapshot = readMoltnetSqlite(database), messages = moltnetMessages(snapshot);
+        const findings = [];
+        const check = (instant, kind, detail) => {
+            if (compareInstants(instant, at) > 0)
+                findings.push({ class: kind, path: file, detail });
+        };
+        for (const agent of Object.values(snapshot.agents)) {
+            for (const field of ["created_at", "updated_at"]) {
+                if (agent[field])
+                    check(agent[field], "moltnet-event", `Agent ${agent.agent_id} has a future ${field}`);
+            }
+        }
+        for (const row of readMoltnetSqliteMigrations(database)) {
+            check(sqliteText(row, "applied_at"), "moltnet-event", `Schema migration ${row.version} has a future applied_at`);
+        }
+        for (const message of messages)
+            check(message.created_at, "moltnet-message", `Message ${message.id} is later than the moment`);
+        for (const room of Object.values(snapshot.rooms))
+            check(room.created_at, "moltnet-room", `Room ${room.id} is later than the moment`);
+        for (const [id, instant] of Object.entries(snapshot.removed_rooms))
+            check(instant, "moltnet-room", `Room ${id} has a future removal marker`);
+        for (const row of database.prepare("SELECT id, created_at FROM artifacts").all()) {
+            check(sqliteText(row, "created_at"), "moltnet-message", `Artifact ${row.id} is later than the moment`);
+        }
+        for (const [table, id] of [["threads", "id"], ["dm_conversations", "dm_id"]]) {
+            for (const row of database.prepare(`SELECT ${id}, last_message_at FROM ${table}`).all()) {
+                check(sqliteText(row, "last_message_at"), "moltnet-message", `${table} ${row[id]} has a future counter`);
+            }
+        }
+        const events = database.prepare("SELECT * FROM attachment_delivery_events").all();
+        for (const row of events) {
+            check(sqliteText(row, "created_at"), "moltnet-event", `Attachment event ${row.event_id} is later than the moment`);
+            findings.push(...inspectMoltnetEvent(moltnetEventSchema.parse(sqliteJson(row, "event_json")), at, file));
+        }
+        for (const row of database.prepare("SELECT agent_id, updated_at FROM attachment_delivery_cursors").all()) {
+            check(sqliteText(row, "updated_at"), "moltnet-event", `Attachment cursor ${row.agent_id} has a future updated_at`);
+        }
+        const appendPositions = new Map(database.prepare("SELECT id, rowid AS append_index FROM messages").all()
+            .map(row => [sqliteText(row, "id"), sqliteInteger(row, "append_index")]));
+        const orderedMessages = messages.filter((message) => (filter.room === undefined || message.target.room_id === filter.room)
+            && (filter.sender === undefined || message.from.id === filter.sender))
+            .map(message => ({ ...message, appendIndex: appendPositions.get(message.id) }))
+            .sort((a, b) => a.created_at < b.created_at ? -1 : a.created_at > b.created_at ? 1
+            : a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        const registrations = Object.values(snapshot.agents).map(agent => ({
+            agentId: agent.agent_id, networkId: agent.network_id, actorUid: agent.actor_uid
+        })).sort((a, b) => a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0);
+        const rooms = Object.values(snapshot.rooms).filter(room => !Object.hasOwn(snapshot.removed_rooms, room.id))
+            .map(room => ({ id: room.id, networkId: room.network_id, memberIds: [...(room.members ?? [])].sort() }))
+            .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+        // Compare inside SQLite so this audit projection never reads credential values into its rows.
+        const nonCanonicalCredentialAgentIds = database.prepare("SELECT agent_id FROM agents WHERE credential_key IS NULL OR credential_key != 'token:' || agent_id ORDER BY agent_id").all().map(row => sqliteText(row, "agent_id"));
+        return { messages: messages.length, events: events.length, findings, orderedMessages,
+            registrations, rooms, nonCanonicalCredentialAgentIds };
+    }
+    finally {
+        database.close();
+    }
+};

package/dist/compiler/training/rewind/moltnetSqliteData.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseSync, SQLOutputValue } from "node:sqlite";
+import { type MoltnetSnapshot } from "./moltnetSchemas.js";
+export type SqliteRow = Record<string, SQLOutputValue>;
+export declare const sqliteText: (row: SqliteRow, key: string) => string;
+export declare const sqliteInteger: (row: SqliteRow, key: string) => number;
+export declare const sqliteJson: (row: SqliteRow, key: string) => unknown;
+export declare const readMoltnetSqliteMigrations: (database: DatabaseSync) => SqliteRow[];
+/** A snapshot is an offline store: unknown tables, views or triggers cannot be safely rewound. */
+export declare const validateSqliteLayout: (database: DatabaseSync) => void;
+export declare const readMoltnetSqlite: (database: DatabaseSync) => MoltnetSnapshot;

package/dist/compiler/training/rewind/moltnetSqliteData.js

@@ -0,0 +1,113 @@
+import { parseMoltnetSnapshot } from "./moltnetJson.js";
+import { moltnetEventSchema } from "./moltnetSchemas.js";
+export const sqliteText = (row, key) => {
+    if (typeof row[key] !== "string")
+        throw new Error(`Invalid Moltnet SQLite ${key}: expected text`);
+    return row[key];
+};
+export const sqliteInteger = (row, key) => {
+    const value = row[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`Invalid Moltnet SQLite ${key}: expected nonnegative safe integer`);
+    }
+    return value;
+};
+export const sqliteJson = (row, key) => {
+    try {
+        return JSON.parse(sqliteText(row, key));
+    }
+    catch (error) {
+        throw new Error(`Invalid Moltnet SQLite ${key}: ${error.message}`);
+    }
+};
+export const readMoltnetSqliteMigrations = (database) => database.prepare("SELECT name FROM sqlite_schema WHERE name = 'schema_migrations'").get()
+    ? database.prepare("SELECT version, applied_at FROM schema_migrations").all() : [];
+const allowedColumns = {
+    rooms: ["id", "network_id", "fqid", "name", "created_at", "deleted_at", "visibility", "write_policy", "federation"],
+    room_members: ["room_id", "member_id"],
+    threads: ["id", "network_id", "fqid", "room_id", "parent_message_id", "message_count", "last_message_at"],
+    messages: ["id", "network_id", "target_kind", "room_id", "thread_id", "parent_message_id", "dm_id", "target_json",
+        "from_json", "parts_json", "mentions_json", "created_at", "origin_json"],
+    dm_conversations: ["dm_id", "network_id", "fqid", "message_count", "last_message_at"],
+    dm_participants: ["dm_id", "participant_id"],
+    artifacts: ["id", "network_id", "fqid", "message_id", "target_kind", "room_id", "thread_id", "dm_id", "target_json",
+        "part_index", "kind", "media_type", "filename", "url", "created_at"],
+    agents: ["agent_id", "network_id", "actor_uid", "actor_uri", "display_name", "credential_key", "created_at", "updated_at"],
+    attachment_delivery_events: ["seq", "event_id", "event_json", "created_at"],
+    attachment_delivery_cursors: ["agent_id", "event_seq", "updated_at"],
+    schema_migrations: ["version", "name", "applied_at"], sqlite_sequence: ["name", "seq"]
+};
+/** A snapshot is an offline store: unknown tables, views or triggers cannot be safely rewound. */
+export const validateSqliteLayout = (database) => {
+    for (const row of database.prepare("SELECT type, name FROM sqlite_schema WHERE type IN ('table', 'view', 'trigger')").all()) {
+        const table = sqliteText(row, "name");
+        if (row.type !== "table" || !Object.hasOwn(allowedColumns, table)) {
+            throw new Error(`Unsupported Moltnet SQLite ${row.type} ${row.name}; cannot establish its historical contents`);
+        }
+        for (const column of database.prepare(`PRAGMA table_info(${table})`).all()) {
+            if (!allowedColumns[table].includes(sqliteText(column, "name"))) {
+                throw new Error(`Unsupported Moltnet SQLite column ${table}.${column.name}; cannot establish its historical contents`);
+            }
+        }
+    }
+};
+export const readMoltnetSqlite = (database) => {
+    validateSqliteLayout(database);
+    const rooms = {}, removed = {}, threads = {};
+    const roomMessages = {}, threadMessages = {}, directMessages = {};
+    const directMembers = {}, agents = {};
+    const roomMembers = database.prepare("SELECT room_id, member_id FROM room_members").all();
+    for (const row of database.prepare("SELECT * FROM rooms").all()) {
+        const id = sqliteText(row, "id");
+        rooms[id] = { id, network_id: row.network_id, fqid: row.fqid, name: row.name, created_at: row.created_at,
+            members: roomMembers.filter((member) => member.room_id === id).map((member) => member.member_id),
+            ...(row.visibility !== undefined ? { visibility: row.visibility } : {}),
+            ...(row.write_policy !== undefined ? { write_policy: row.write_policy } : {}),
+            ...(row.federation !== undefined ? { federation: sqliteJson(row, "federation") } : {}) };
+        if (row.deleted_at !== null && row.deleted_at !== undefined && row.deleted_at !== "")
+            removed[id] = row.deleted_at;
+    }
+    for (const row of database.prepare("SELECT * FROM threads").all())
+        threads[sqliteText(row, "id")] = {
+            id: row.id, network_id: row.network_id, fqid: row.fqid, room_id: row.room_id,
+            parent_message_id: row.parent_message_id, message_count: row.message_count, last_message_at: row.last_message_at
+        };
+    // rowid preserves append order for a DM's first/root message; random message IDs do not.
+    for (const row of database.prepare("SELECT * FROM messages ORDER BY rowid").all()) {
+        const target = sqliteJson(row, "target_json");
+        for (const [column, key] of [["target_kind", "kind"], ["room_id", "room_id"], ["thread_id", "thread_id"],
+            ["parent_message_id", "parent_message_id"], ["dm_id", "dm_id"]]) {
+            if ((row[column] ?? "") !== (target?.[key] ?? ""))
+                throw new Error(`Moltnet SQLite message ${row.id}: ${column} disagrees with target_json`);
+        }
+        const message = { id: row.id, network_id: row.network_id, target,
+            from: sqliteJson(row, "from_json"), parts: sqliteJson(row, "parts_json"), mentions: sqliteJson(row, "mentions_json"),
+            created_at: row.created_at, ...(row.origin_json !== undefined && row.origin_json !== "{}"
+                ? { origin: sqliteJson(row, "origin_json") } : {}) };
+        const group = row.target_kind === "room" ? roomMessages : row.target_kind === "thread" ? threadMessages
+            : row.target_kind === "dm" ? directMessages : undefined;
+        if (!group)
+            throw new Error(`Unknown Moltnet SQLite message target kind ${row.target_kind}`);
+        const key = sqliteText(row, row.target_kind === "room" ? "room_id" : row.target_kind === "thread" ? "thread_id" : "dm_id");
+        (group[key] ??= []).push(message);
+    }
+    for (const row of database.prepare("SELECT dm_id, participant_id FROM dm_participants").all()) {
+        (directMembers[sqliteText(row, "dm_id")] ??= {})[sqliteText(row, "participant_id")] = {};
+    }
+    for (const row of database.prepare("SELECT * FROM agents").all())
+        agents[sqliteText(row, "agent_id")] = {
+            ...row, ...(row.display_name === null ? { display_name: "" } : {})
+        };
+    const eventRows = database.prepare("SELECT * FROM attachment_delivery_events ORDER BY seq").all();
+    const events = eventRows.map((row) => {
+        const event = moltnetEventSchema.parse(sqliteJson(row, "event_json"));
+        if (event.id !== row.event_id)
+            throw new Error(`Moltnet SQLite event ${row.event_id} disagrees with event_json`);
+        return event;
+    });
+    const cursors = Object.fromEntries(database.prepare("SELECT * FROM attachment_delivery_cursors").all()
+        .map((row) => [sqliteText(row, "agent_id"), eventRows.filter((event) => sqliteInteger(event, "seq") <= sqliteInteger(row, "event_seq")).length]));
+    return parseMoltnetSnapshot({ rooms, removed_rooms: removed, threads, room_messages: roomMessages,
+        thread_messages: threadMessages, direct_messages: directMessages, direct_members: directMembers,
+        agents, attachment_delivery_events: events, attachment_delivery_cursors: cursors });
+};

package/dist/compiler/training/rewind/recordInput.d.ts

@@ -0,0 +1,40 @@
+import type { MomentRecord } from "../../../recording/index.js";
+import type { InputIdentity, RewindInput } from "./types.js";
+/** Merged recording keeps deployment uncertainty at record level, rather than naming each pin. */
+export declare const recordActivationErrors: (record: MomentRecord | null) => string[];
+/** Errors are free text in P3: honor explicit qualifications; otherwise conservatively match the whole ID. */
+export declare const recordInputErrors: (record: MomentRecord, input: InputIdentity) => string[];
+/** Do not discard healthy pins just because another input made the whole record inexact. */
+export declare const recordForInput: (record: MomentRecord | null, input: InputIdentity) => MomentRecord | null;
+export declare const recordPins: (record: MomentRecord | null, input: InputIdentity | RewindInput) => {
+    id: string;
+    declaredBy: string;
+    seq: number;
+    generation?: number | undefined;
+}[] | {
+    network: string;
+    cursor: string;
+    messageIds?: string[] | undefined;
+}[] | ({
+    id: string;
+    kind: "git";
+    commit: string;
+    sha256?: string | undefined;
+} | {
+    id: string;
+    kind: "bundle";
+    sha256: string;
+} | {
+    id: string;
+    revision: string;
+    tree: string;
+    landedAt: string;
+    commit?: string | undefined;
+    ref?: string | undefined;
+    paths?: string[] | undefined;
+    period?: string | undefined;
+} | {
+    id: string;
+    snapshot: string;
+})[];
+export declare const hasRecordPin: (record: MomentRecord | null, input: InputIdentity | RewindInput) => boolean;

package/dist/compiler/training/rewind/recordInput.js

@@ -0,0 +1,49 @@
+const sections = {
+    resource: "resources", resources: "resources", git: "resources", bundle: "resources", bundles: "resources",
+    feed: "resources", feeds: "resources", volume: "resources", volumes: "resources",
+    memory: "memory", bank: "memory", banks: "memory", moltnet: "networks", network: "networks", networks: "networks"
+};
+const ownerPattern = "(?:agent|team|org|organization):[A-Za-z0-9_.:/-]+?";
+const qualifiedPrefix = new RegExp(`(?:^|[^A-Za-z0-9_.-])(${Object.keys(sections).join("|")})`
+    + `(?:[\\s/]+(${ownerPattern}))?[\\s/:]+$`, "iu");
+const ownerPrefix = new RegExp(`(?:^|[^A-Za-z0-9_.-])(${ownerPattern})[\\s/]+$`, "u");
+const ownerSuffix = new RegExp(`^\\s*(?:\\(\\s*|declaredBy\\s*[=:]\\s*|@\\s*)(${ownerPattern})(?=[\\s):,;]|$)`, "u");
+/** Merged recording keeps deployment uncertainty at record level, rather than naming each pin. */
+export const recordActivationErrors = (record) => (record?.errors ?? []).filter((error) => error.includes("Deployment activation is non-exact"));
+/** Errors are free text in P3: honor explicit qualifications; otherwise conservatively match the whole ID. */
+export const recordInputErrors = (record, input) => {
+    const escaped = input.id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const namesInput = new RegExp(`(?<![A-Za-z0-9_.-])${escaped}(?![A-Za-z0-9_.-])`, "gu");
+    return (record.errors ?? []).filter((error) => {
+        if (recordActivationErrors(record).includes(error))
+            return false;
+        let decoded = error;
+        try {
+            decoded = decodeURIComponent(error);
+        }
+        catch { /* A literal percent is valid free text. */ }
+        return [...decoded.matchAll(namesInput)].some((match) => {
+            const prefix = decoded.slice(0, match.index);
+            const qualification = qualifiedPrefix.exec(prefix);
+            if (qualification && sections[qualification[1].toLowerCase()] !== input.section)
+                return false;
+            const owner = qualification?.[2] ?? ownerPrefix.exec(prefix)?.[1]
+                ?? ownerSuffix.exec(decoded.slice(match.index + match[0].length))?.[1];
+            return !owner || owner === input.declaredBy;
+        });
+    });
+};
+/** Do not discard healthy pins just because another input made the whole record inexact. */
+export const recordForInput = (record, input) => record && !recordInputErrors(record, input).length ? record : null;
+export const recordPins = (record, input) => {
+    if (!record)
+        return [];
+    if (input.section === "memory")
+        return record.memory.filter((entry) => entry.id === input.id && entry.declaredBy === input.declaredBy);
+    if (input.section === "networks")
+        return record.moltnet.filter((entry) => entry.network === input.id);
+    const pins = !("declaration" in input) ? [...record.resources, ...record.feeds, ...record.volumes]
+        : input.declaration.kind !== "volume" ? record.resources : input.declaration.feed ? record.feeds : record.volumes;
+    return pins.filter((entry) => entry.id === input.id);
+};
+export const hasRecordPin = (record, input) => recordPins(record, input).length > 0;

package/dist/compiler/training/rewind/recordedBundle.d.ts

@@ -0,0 +1,4 @@
+import type { History } from "./history.js";
+export declare const materializeRecordedBundle: (history: History | undefined, sha256: string, destination: string) => Promise<boolean>;
+/** Acceptance reopens the digest-pinned archive and compares disk bytes, without trusting producer metadata. */
+export declare const verifyRecordedBundle: (history: History | undefined, sha256: string, directory: string) => Promise<void>;

package/dist/compiler/training/rewind/recordedBundle.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { validateWorkspaceBundleTar } from "../../workspaceBundleArtifacts.js";
+import { recordedSha256Schema } from "../../../recording/index.js";
+import { extractBundleBytes } from "./gitTree.js";
+const recordedBytes = async (history, sha256) => {
+    recordedSha256Schema.parse(sha256);
+    const bytes = await history?.bytes(`bundles/${sha256.slice(7)}.tar`);
+    if (!bytes || bytes.length > 536_870_912 || `sha256:${createHash("sha256").update(bytes).digest("hex")}` !== sha256)
+        return null;
+    return bytes;
+};
+export const materializeRecordedBundle = async (history, sha256, destination) => {
+    const bytes = await recordedBytes(history, sha256);
+    if (!bytes)
+        return false;
+    await extractBundleBytes(bytes, destination);
+    return true;
+};
+/** Acceptance reopens the digest-pinned archive and compares disk bytes, without trusting producer metadata. */
+export const verifyRecordedBundle = async (history, sha256, directory) => {
+    const bytes = await recordedBytes(history, sha256);
+    if (!bytes)
+        throw new Error(`Recorded bundle ${sha256} could not be reproduced`);
+    validateWorkspaceBundleTar(bytes);
+    const text = (field) => field.toString("utf8").replace(/\0.*$/su, "");
+    const files = new Map(), directories = new Set();
+    for (let offset = 0; offset < bytes.length && !bytes.subarray(offset, offset + 512).every((byte) => byte === 0);) {
+        const header = bytes.subarray(offset, offset + 512), prefix = text(header.subarray(345, 500));
+        const name = `${prefix ? `${prefix}/` : ""}${text(header.subarray(0, 100))}`.replace(/\/$/u, "");
+        const size = Number.parseInt(text(header.subarray(124, 136)).trim(), 8);
+        for (let parent = path.posix.dirname(name); parent !== "."; parent = path.posix.dirname(parent))
+            directories.add(parent);
+        if (header[156] === 53)
+            directories.add(name);
+        else
+            files.set(name, { bytes: bytes.subarray(offset + 512, offset + 512 + size), executable: Boolean(Number.parseInt(text(header.subarray(100, 108)).trim(), 8) & 0o111) });
+        offset += 512 + Math.ceil(size / 512) * 512;
+    }
+    const walk = async (folder, prefix = "") => {
+        for (const name of await readdir(folder)) {
+            const relative = prefix ? `${prefix}/${name}` : name, full = path.join(folder, name), stats = await lstat(full);
+            if (stats.isDirectory() && directories.delete(relative))
+                await walk(full, relative);
+            else {
+                const expected = files.get(relative);
+                if (!stats.isFile() || !expected || Boolean(stats.mode & 0o111) !== expected.executable || !(await readFile(full)).equals(expected.bytes)) {
+                    throw new Error(`Recorded bundle entry mismatch: ${relative}`);
+                }
+                files.delete(relative);
+            }
+        }
+    };
+    await walk(directory);
+    if (files.size || directories.size)
+        throw new Error(`Missing recorded bundle entries: ${[...files.keys(), ...directories].join(", ")}`);
+};

package/dist/compiler/training/rewind/recordedCommit.d.ts

@@ -0,0 +1,2 @@
+/** Recorded identity names the commit object itself, never a selector or a peeled tag. */
+export declare const resolveRecordedCommit: (repository: string, value: string) => Promise<string>;

package/dist/compiler/training/rewind/recordedCommit.js

@@ -0,0 +1,10 @@
+import { recordedCommitSchema } from "../../../recording/index.js";
+import { rewindGit } from "./gitProcess.js";
+/** Recorded identity names the commit object itself, never a selector or a peeled tag. */
+export const resolveRecordedCommit = async (repository, value) => {
+    const commit = recordedCommitSchema.parse(value);
+    const type = (await rewindGit(repository, ["cat-file", "-t", commit])).toString().trim();
+    if (type !== "commit")
+        throw new Error(`Recorded object ${commit} must be a commit object; found ${type}`);
+    return commit;
+};

package/dist/compiler/training/rewind/select.d.ts

@@ -0,0 +1,18 @@
+import type { TrainingPlan } from "../plan/index.js";
+import type { MomentRecord } from "../../../recording/index.js";
+import type { InputIdentity, RewindInput } from "./types.js";
+export type DatasetRole = "train" | "validation" | "test";
+export interface SelectedExample {
+    id: string;
+    role: DatasetRole;
+    dataset: string;
+    sourcePath: string;
+    example: TrainingPlan["targets"][number]["datasets"]["train"]["examples"][number];
+}
+/** Shared targets referencing the same role/dataset/example are one trial. */
+export declare const selectTrainingExample: (plan: TrainingPlan, selector: string) => SelectedExample;
+export declare const matchingMomentRecords: (records: readonly MomentRecord[], agent: string, at: string) => MomentRecord[];
+/** Replays can share executionId AND startedAt. Keep every earliest tie for per-input agreement. */
+export declare const originalMomentRecords: (records: readonly MomentRecord[]) => MomentRecord[];
+/** Capture time and wake payload are not used to materialize data. Normalize actual used instants. */
+export declare const selectMomentRecord: (records: MomentRecord[], agent: string, at: string, inputs?: Array<InputIdentity | RewindInput>) => MomentRecord | null;