spawnfile 0.1.14 → 0.1.18

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

@@ -0,0 +1,78 @@
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { rewindGit } from "./gitProcess.js";
+import { instantNanos } from "./instant.js";
+import { inspectGitIndexTimes, inspectGitWorktree } from "./leakGitPayload.js";
+/** Enumerate every stored object, independently of the materializer's chosen-object list. */
+export const inspectGitBundle = async (repository, input, report) => {
+    const add = (detail) => report.findings.push({
+        input: { section: input.section, id: input.id, declaredBy: input.declaredBy },
+        class: "git-object", path: input.path, detail
+    });
+    const gitDir = path.join(repository, ".git");
+    if (!(await lstat(gitDir)).isDirectory())
+        throw new Error("The materialized repository must have its own .git directory");
+    const names = new Set(await readdir(gitDir));
+    for (const name of ["FETCH_HEAD", "ORIG_HEAD", "logs", "packed-refs", "commondir", "shallow"]) {
+        if (names.has(name))
+            add(`Forbidden git metadata ${name}`);
+    }
+    const config = await readFile(path.join(gitDir, "config"), "utf8");
+    if (/^\s*\[\s*(?:include|includeif)\b/imu.test(config))
+        throw new Error("Git configuration includes are forbidden");
+    for (const name of ["objects/info/alternates", "objects/info/http-alternates", "info/grafts"]) {
+        const exists = await lstat(path.join(gitDir, name)).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (exists)
+            throw new Error(`Git object indirection ${name} is forbidden`);
+    }
+    const localConfig = (await rewindGit(repository, ["config", "--local", "--no-includes", "--list", "--null"]))
+        .toString().split("\0").filter(Boolean);
+    for (const entry of localConfig) {
+        const key = entry.split("\n")[0].toLowerCase();
+        if (key.startsWith("remote.") || key === "core.worktree" || key === "extensions.partialclone")
+            add(`Forbidden git configuration ${key}`);
+    }
+    const refs = (await rewindGit(repository, ["for-each-ref", "--format=%(refname) %(objectname)"])).toString().trim().split("\n").filter(Boolean);
+    const head = (await readFile(path.join(gitDir, "HEAD"), "utf8")).trim();
+    const commit = input.source.commit;
+    if (!commit || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(commit))
+        throw new Error("Missing materialized commit identity");
+    if (refs.length !== 1 || !refs[0].startsWith("refs/heads/") || refs[0].split(" ")[1] !== commit
+        || head !== `ref: ${refs[0]?.split(" ")[0]}`)
+        add("Exactly one branch and HEAD must name the materialized commit");
+    const reachable = new Set((await rewindGit(repository, ["rev-list", "--objects", commit, "--"]))
+        .toString().split("\n").filter(Boolean).map((line) => line.split(" ")[0]));
+    const objects = (await rewindGit(repository, ["cat-file", "--batch-all-objects", "--batch-check=%(objectname) %(objecttype)"]))
+        .toString().trim().split("\n").filter(Boolean);
+    report.checked.gitObjects += objects.length;
+    for (const row of objects) {
+        const [oid, kind] = row.split(" ");
+        if (!reachable.has(oid))
+            add(`Object ${oid} is not reachable from ${commit}`);
+        if (kind !== "commit")
+            continue;
+        const object = (await rewindGit(repository, ["cat-file", "commit", oid])).toString();
+        const headers = object.split("\n\n", 1)[0];
+        for (const role of ["author", "committer"]) {
+            const match = new RegExp(`^${role} .* (-?\\d+) [+-]\\d{4}$`, "mu").exec(headers);
+            if (!match) {
+                add(`Commit ${oid} has no valid ${role} date`);
+                continue;
+            }
+            if (BigInt(match[1]) * 1000000000n > instantNanos(report.at))
+                add(`Commit ${oid} has a future ${role} date`);
+        }
+    }
+    for (const inspect of [() => inspectGitWorktree(repository, commit), () => inspectGitIndexTimes(repository, report.at)]) {
+        try {
+            await inspect();
+        }
+        catch (error) {
+            add(error instanceof Error ? error.message : String(error));
+        }
+    }
+};

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

@@ -0,0 +1,4 @@
+/** Compare against objects in the output repository, never the index or status' cached stat data. */
+export declare const inspectGitWorktree: (repository: string, commit: string) => Promise<void>;
+/** NUL terminates each pathname, so path text cannot masquerade as --debug stat metadata. */
+export declare const inspectGitIndexTimes: (repository: string, at: string) => Promise<void>;

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

@@ -0,0 +1,57 @@
+import { lstat, readFile, readdir, readlink } from "node:fs/promises";
+import path from "node:path";
+import { rewindGit } from "./gitProcess.js";
+import { safeCommittedPath } from "./gitTree.js";
+import { instantNanos } from "./instant.js";
+/** Compare against objects in the output repository, never the index or status' cached stat data. */
+export const inspectGitWorktree = async (repository, commit) => {
+    const entries = new Map();
+    for (const row of (await rewindGit(repository, ["ls-tree", "-rtz", `${commit}^{tree}`])).toString().split("\0").filter(Boolean)) {
+        const tab = row.indexOf("\t"), name = safeCommittedPath(row.slice(tab + 1));
+        const [mode, kind, oid] = row.slice(0, tab).split(" ");
+        entries.set(name, { mode: mode, kind: kind, oid: oid });
+    }
+    const visit = async (directory, prefix = "") => {
+        for (const name of await readdir(directory)) {
+            if (!prefix && name === ".git")
+                continue;
+            const relative = prefix ? `${prefix}/${name}` : name, file = path.join(directory, name);
+            const expected = entries.get(relative), stats = await lstat(file);
+            if (!expected)
+                throw new Error(`Unexpected git worktree entry ${relative}`);
+            entries.delete(relative);
+            if (expected.kind === "tree" && stats.isDirectory()) {
+                await visit(file, relative);
+                continue;
+            }
+            if (expected.kind !== "blob" || !["100644", "100755", "120000"].includes(expected.mode)) {
+                throw new Error(`Unsupported git worktree entry ${relative}`);
+            }
+            const bytes = await rewindGit(repository, ["cat-file", "blob", expected.oid]);
+            const matches = expected.mode === "120000"
+                ? stats.isSymbolicLink() && (await readlink(file, { encoding: "buffer" })).equals(bytes)
+                : stats.isFile() && Boolean(stats.mode & 0o111) === (expected.mode === "100755") && (await readFile(file)).equals(bytes);
+            if (!matches)
+                throw new Error(`Git worktree entry mismatch: ${relative}`);
+        }
+    };
+    await visit(repository);
+    if (entries.size)
+        throw new Error(`Missing git worktree entries: ${[...entries.keys()].join(", ")}`);
+};
+/** NUL terminates each pathname, so path text cannot masquerade as --debug stat metadata. */
+export const inspectGitIndexTimes = async (repository, at) => {
+    const debug = (await rewindGit(repository, ["ls-files", "--debug", "-z"])).toString();
+    for (let cursor = 0; cursor < debug.length;) {
+        const end = debug.indexOf("\0", cursor);
+        const metadata = end < 0 ? null : /^  ctime: (\d+):(\d+)\n  mtime: (\d+):(\d+)\n  dev: [^\n]+\n  uid: [^\n]+\n  size: [^\n]+\n/u.exec(debug.slice(end + 1));
+        if (!metadata)
+            throw new Error("Invalid git index stat metadata");
+        for (const [label, offset] of [["ctime", 1], ["mtime", 3]]) {
+            const nanos = BigInt(metadata[offset]) * 1000000000n + BigInt(metadata[offset + 1]);
+            if (nanos > instantNanos(at))
+                throw new Error(`Git index ${label} is later than the moment: ${debug.slice(cursor, end)}`);
+        }
+        cursor = end + 1 + metadata[0].length;
+    }
+};

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

@@ -0,0 +1,7 @@
+import type { LeakCheck, LeakFinding, MaterializedInput, MaterializedMoment } from "./contract.js";
+import { type History } from "./history.js";
+export declare const addInputFinding: (report: LeakCheck, input: MaterializedInput, kind: LeakFinding["class"], detail: string, file?: string) => void;
+export declare const inspectMemoryBundle: (root: string, input: MaterializedInput, report: LeakCheck) => Promise<void>;
+export declare const inspectFeedBundle: (root: string, input: MaterializedInput, report: LeakCheck, moment?: MaterializedMoment, history?: History) => Promise<void>;
+export declare const inspectMoltnetBundle: (root: string, input: MaterializedInput, report: LeakCheck) => Promise<void>;
+export declare const inspectVolumeBundle: (root: string, input: MaterializedInput, report: LeakCheck, history?: History) => Promise<void>;

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

@@ -0,0 +1,135 @@
+import { lstat, readFile, readdir, readlink, realpath } from "node:fs/promises";
+import path from "node:path";
+import { feedIdentityFindings } from "../../../volume/feedRecord.js";
+import { digestDirectory } from "../../../volume/index.js";
+import { assertPreparedFeedRevision, feedGitRevision, verifyPlainFeedTree } from "./feedContent.js";
+import { assertLocalGitRepository } from "./gitHistory.js";
+import { permitsFeedPublicationTime } from "./leakFeed.js";
+import { historyKey, inside, safeSegment } from "./history.js";
+import { compareInstants } from "./instant.js";
+import { diskPath } from "./leakFiles.js";
+import { assertDirectoryEntries } from "./leakLayout.js";
+import { parseMemoryLedger } from "./memory.js";
+import { inspectMoltnetJson } from "./moltnetJson.js";
+import { inspectMoltnetSqlite } from "./moltnetSqlite.js";
+import { readSnapshotManifest, snapshotBytes, snapshotHistoryPath, snapshotTreeFindings } from "./snapshotManifest.js";
+export const addInputFinding = (report, input, kind, detail, file = input.path) => {
+    report.findings.push({ input: { section: input.section, id: input.id, declaredBy: input.declaredBy }, class: kind, path: file, detail });
+};
+export const inspectMemoryBundle = async (root, input, report) => {
+    const home = await diskPath(root, input.path);
+    await assertDirectoryEntries(home, { memory: "directory" });
+    await assertDirectoryEntries(path.join(home, "memory"), { "events.jsonl": "file" });
+    const ledger = parseMemoryLedger(await readFile(await diskPath(root, `${input.path}/memory/events.jsonl`), "utf8"));
+    report.checked.memoryEvents += ledger.events.length;
+    let native = false;
+    for (const [index, event] of ledger.events.entries()) {
+        if (event.seq === undefined ? native : event.seq !== index + 1) {
+            addInputFinding(report, input, "memory-event", `Noncontiguous memory sequence at line ${index + 1}`);
+        }
+        native ||= event.seq !== undefined;
+        if (compareInstants(event.createdAt, report.at) > 0)
+            addInputFinding(report, input, "memory-event", `Future memory event at line ${index + 1}`);
+        if (index > 0 && compareInstants(event.createdAt, ledger.events[index - 1].createdAt) < 0) {
+            addInputFinding(report, input, "memory-event", `Memory clock regression at line ${index + 1}`);
+        }
+    }
+    if (input.source.seq !== ledger.events.length)
+        addInputFinding(report, input, "memory-event", "Ledger length disagrees with the materialized sequence");
+};
+export const inspectFeedBundle = async (root, input, report, moment, history) => {
+    const directory = await diskPath(root, input.path);
+    if (input.fidelity === "overridden") {
+        if ((await readdir(directory)).length)
+            addInputFinding(report, input, "feed-identity", "Overridden feed volume must be empty");
+        return;
+    }
+    const identity = JSON.parse(await readFile(await diskPath(root, `${input.path}/.spawnfile-feed.json`), "utf8"));
+    await assertDirectoryEntries(directory, { current: "symlink", ".spawnfile-feed.json": "file", trees: "directory" });
+    for (const issue of feedIdentityFindings(identity))
+        addInputFinding(report, input, "feed-identity", issue);
+    if (compareInstants(identity.landed_at, report.at) > 0 && !(moment && await permitsFeedPublicationTime(identity, input, moment, history))) {
+        addInputFinding(report, input, "feed-identity", "Feed landed_at is later than the moment");
+    }
+    if (identity.resource !== input.id || identity.revision !== input.source.revision) {
+        addInputFinding(report, input, "feed-identity", "Feed identity disagrees with the moment input");
+    }
+    const current = path.join(directory, "current");
+    if (!(await lstat(current)).isSymbolicLink())
+        throw new Error("Feed current must be a relative symlink");
+    const link = await readlink(current);
+    if (link !== identity.tree || !/^trees\/[a-f0-9]{64}(?:\.[1-9][0-9]*)?$/u.test(link)
+        || !inside(path.join(directory, "trees"), await realpath(current))) {
+        addInputFinding(report, input, "feed-identity", "Feed current does not point to its tree inside the volume");
+    }
+    else if (!(await lstat(await realpath(current))).isDirectory())
+        addInputFinding(report, input, "feed-identity", "Feed tree must be a directory");
+    else {
+        await assertDirectoryEntries(path.join(directory, "trees"), { [path.basename(link)]: "directory" });
+        const prepared = identity.source.prepared !== undefined || input.source.prepared === true;
+        if (prepared && (input.fidelity !== "approximate" || !input.notes.includes("prepared output not content-verifiable"))) {
+            addInputFinding(report, input, "feed-identity", "Prepared feed must be approximate: prepared output not content-verifiable");
+        }
+        if (identity.source.prepared)
+            assertPreparedFeedRevision(identity.revision, identity.source.prepared);
+        if (identity.source.kind === "directory" && !prepared && digestDirectory(await realpath(current)) !== identity.revision) {
+            addInputFinding(report, input, "feed-identity", "Directory feed revision disagrees with retained bytes");
+        }
+        if (identity.source.kind === "git") {
+            const repository = await history?.repository(`feeds/${historyKey(input)}/repo`);
+            if (!repository)
+                throw new Error("Missing feed source history repository for content verification");
+            await assertLocalGitRepository(repository, history);
+            if (!prepared)
+                await verifyPlainFeedTree(repository, identity, await realpath(current));
+            else if (identity.source.prepared && feedGitRevision(repository, identity.source.commit, identity.source.ref, identity.source.paths)
+                !== identity.source.prepared.source_revision)
+                throw new Error("Prepared feed source revision disagrees with selected commit and paths");
+        }
+    }
+};
+export const inspectMoltnetBundle = async (root, input, report) => {
+    const directory = await diskPath(root, input.path);
+    const stores = (await readdir(directory)).filter((name) => name === "state.json" || name === "moltnet.sqlite");
+    if (stores.length !== 1)
+        throw new Error("Expected exactly one Moltnet store");
+    await assertDirectoryEntries(directory, { [stores[0]]: "file" });
+    const store = await diskPath(root, `${input.path}/${stores[0]}`);
+    const result = stores[0] === "state.json" ? await inspectMoltnetJson(store, report.at) : await inspectMoltnetSqlite(store, report.at);
+    report.checked.moltnetMessages += result.messages;
+    report.checked.moltnetEvents += result.events;
+    for (const finding of result.findings)
+        addInputFinding(report, input, finding.class, finding.detail, path.relative(root, finding.path));
+};
+export const inspectVolumeBundle = async (root, input, report, history) => {
+    const directory = await diskPath(root, input.path);
+    if (input.fidelity === "overridden") {
+        for (const name of await readdir(directory))
+            addInputFinding(report, input, "snapshot", `Unexpected snapshot entry ${name}`);
+        return;
+    }
+    if (!history || !input.source.snapshot || !input.source.agentSlug)
+        throw new Error("Snapshot verification requires its history, agent slug and selected snapshot");
+    if (input.source.snapshot.endsWith(".partial"))
+        throw new Error("Selected snapshot is partial");
+    const relative = snapshotHistoryPath(input.source.agentSlug, input.id, input.source.snapshot);
+    const manifest = await readSnapshotManifest(history, relative, input.id, input.source.snapshot);
+    const retained = await history.path(relative);
+    if (!manifest || !retained)
+        throw new Error("Snapshot tree or manifest is missing");
+    if (compareInstants(manifest.started_at, report.at) > 0)
+        throw new Error("Selected snapshot is later than the moment");
+    const rows = await history.wakeMoments(`recording/${safeSegment(input.source.agentSlug)}/wake-moments.jsonl`);
+    if (!rows?.some((row) => compareInstants(row.started_at, manifest.started_at) === 0
+        && row.snapshots.some((entry) => entry.id === input.id && entry.snapshot === input.source.snapshot))) {
+        throw new Error("Selected snapshot has no matching wake row");
+    }
+    report.checked.snapshots++;
+    for (const detail of await snapshotTreeFindings(retained, manifest, { retained: true }))
+        addInputFinding(report, input, "snapshot", `Retained ${detail}`);
+    for (const detail of await snapshotTreeFindings(directory, manifest, {
+        readBytes: async (name) => readFile(await diskPath(root, `${input.path}/${name}`)),
+        expectedBytes: (name) => snapshotBytes(history, relative, name)
+    }))
+        addInputFinding(report, input, "snapshot", detail);
+};

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

@@ -0,0 +1,2 @@
+/** Closed native layouts cannot carry unrelated retained bytes, even when their dates are stamped. */
+export declare const assertDirectoryEntries: (directory: string, expected: Record<string, "file" | "directory" | "symlink">) => Promise<void>;

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

@@ -0,0 +1,17 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+/** Closed native layouts cannot carry unrelated retained bytes, even when their dates are stamped. */
+export const assertDirectoryEntries = async (directory, expected) => {
+    const names = await readdir(directory);
+    for (const name of names) {
+        if (!Object.hasOwn(expected, name))
+            throw new Error(`Unexpected payload entry ${name}`);
+        const stat = await lstat(path.join(directory, name)), kind = expected[name];
+        if (!(kind === "file" ? stat.isFile() : kind === "directory" ? stat.isDirectory() : stat.isSymbolicLink())) {
+            throw new Error(`Payload entry ${name} must be a ${kind}`);
+        }
+    }
+    for (const name of Object.keys(expected))
+        if (!names.includes(name))
+            throw new Error(`Missing payload entry ${name}`);
+};

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

@@ -0,0 +1,3 @@
+import type { LeakCheck, MaterializedInput } from "./contract.js";
+/** Read receipts and source objects afresh; never trust the producer's date guard or stamped files. */
+export declare const inspectInputProvenance: (root: string, input: MaterializedInput, report: LeakCheck, historyDir?: string) => Promise<void>;

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

@@ -0,0 +1,88 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { assertLocalGitRepository } from "./gitHistory.js";
+import { rewindGit } from "./gitProcess.js";
+import { historyKey, openHistory } from "./history.js";
+import { instantNanos } from "./instant.js";
+import { diskPath } from "./leakFiles.js";
+import { addInputFinding } from "./leakInputs.js";
+import { verifyRecordedBundle } from "./recordedBundle.js";
+import { digestDirectory } from "../../../volume/index.js";
+import { exportGitTree } from "./gitTree.js";
+const inspectBundleTree = async (repository, commit, directory, input) => {
+    if (!input.source.trees?.length)
+        throw new Error("Missing bundle source tree selection");
+    const scratch = await mkdtemp(path.join(os.tmpdir(), "spawnfile-bundle-check-"));
+    try {
+        for (const tree of input.source.trees)
+            await exportGitTree(repository, commit, scratch, { ...tree, mergeIdentical: true });
+        if (digestDirectory(directory) !== digestDirectory(scratch))
+            throw new Error("Bundle bytes disagree with selected commit, roots and exclusions");
+    }
+    finally {
+        await rm(scratch, { recursive: true, force: true });
+    }
+};
+/** Read receipts and source objects afresh; never trust the producer's date guard or stamped files. */
+export const inspectInputProvenance = async (root, input, report, historyDir) => {
+    const add = (detail) => addInputFinding(report, input, "git-object", detail);
+    try {
+        if (input.kind === "bundle" && (input.basis === "record" || input.basis === "deploy-log") && input.source.sha256) {
+            await verifyRecordedBundle(await openHistory(historyDir), input.source.sha256, await diskPath(root, input.path));
+            return;
+        }
+        const commit = input.source.commit;
+        if (input.kind === "feed") {
+            if (input.fidelity === "overridden")
+                return;
+            const identity = JSON.parse(await readFile(await diskPath(root, `${input.path}/.spawnfile-feed.json`), "utf8"));
+            if (identity.source?.kind === "git") {
+                if (!commit || identity.source.commit !== commit)
+                    add("Feed source commit disagrees with moment provenance");
+            }
+            else if (!commit)
+                return; // Directory feeds have no git provenance.
+        }
+        else if (input.kind === "bundle" && input.fidelity === "overridden" && !commit && !input.source.repository) {
+            return; // Explicit prebuilt tar overrides have no source commit.
+        }
+        if (!commit || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u.test(commit))
+            throw new Error("Missing or invalid source commit provenance");
+        let repository;
+        if (input.source.repository) {
+            // Only locally resolved pins/overrides may lack an entry in the history layout.
+            if (input.kind === "feed" || input.basis !== "pinned" && input.fidelity !== "overridden"
+                || !path.isAbsolute(input.source.repository))
+                throw new Error("Invalid local provenance repository");
+            repository = input.source.repository;
+            await assertLocalGitRepository(repository);
+        }
+        else {
+            const history = await openHistory(historyDir);
+            const key = input.kind === "feed" ? `feeds/${historyKey(input)}/repo` : `git/${historyKey(input)}`;
+            const retained = await history?.repository(key);
+            if (!retained)
+                throw new Error(`Missing source history repository for provenance: ${key}`);
+            repository = retained;
+            await assertLocalGitRepository(repository, history);
+        }
+        const type = (await rewindGit(repository, ["cat-file", "-t", commit])).toString().trim();
+        if (type !== "commit")
+            throw new Error(`Provenance object ${commit} must be a commit object; found ${type}`);
+        const headers = (await rewindGit(repository, ["cat-file", "commit", commit])).toString().split("\n\n", 1)[0];
+        report.checked.gitObjects++;
+        for (const role of ["author", "committer"]) {
+            const match = new RegExp(`^${role} .* (-?\\d+) [+-]\\d{4}$`, "mu").exec(headers);
+            if (!match)
+                add(`Provenance commit ${commit} has no valid ${role} date`);
+            else if (BigInt(match[1]) * 1000000000n > instantNanos(report.at))
+                add(`Provenance commit ${commit} has a future ${role} date`);
+        }
+        if (input.kind === "bundle")
+            await inspectBundleTree(repository, commit, await diskPath(root, input.path), input);
+    }
+    catch (error) {
+        add(error instanceof Error ? error.message : String(error));
+    }
+};

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

@@ -0,0 +1,136 @@
+import type { LoadedTrainingProject, TrainingPlan } from "../plan/index.js";
+import { type MaterializedMoment } from "./contract.js";
+import { type MomentRecord } from "../../../recording/index.js";
+import { type LeakCheckOptions } from "./leakCheck.js";
+import type { RewindInput } from "./types.js";
+export interface MaterializeTrainingMomentOptions {
+    plan: TrainingPlan;
+    project: LoadedTrainingProject;
+    example: string;
+    historyDir?: string;
+    out: string;
+}
+/** Pure core for a per-trial caller: effective declarations, example identity and matching record. */
+export declare const resolveTrainingMoment: (plan: TrainingPlan, project: LoadedTrainingProject, example: string, records?: MomentRecord[]) => {
+    candidateRecords: {
+        version: "spawnfile.moment-record.v1";
+        agent: string;
+        wake: {
+            at: string;
+            startedAt: string;
+            executionId: string;
+            deliveries: {
+                deliveryId: string;
+                kind: string;
+                occurredAt: string;
+            }[];
+            surface?: "moltnet" | undefined;
+            room?: string | undefined;
+            from?: string | undefined;
+            messageId?: string | undefined;
+        };
+        recordedAt: string;
+        exact: boolean;
+        resources: ({
+            id: string;
+            kind: "git";
+            commit: string;
+            sha256?: string | undefined;
+        } | {
+            id: string;
+            kind: "bundle";
+            sha256: string;
+        })[];
+        feeds: {
+            id: string;
+            revision: string;
+            tree: string;
+            landedAt: string;
+            commit?: string | undefined;
+            ref?: string | undefined;
+            paths?: string[] | undefined;
+            period?: string | undefined;
+        }[];
+        memory: {
+            id: string;
+            declaredBy: string;
+            seq: number;
+            generation?: number | undefined;
+        }[];
+        moltnet: {
+            network: string;
+            cursor: string;
+            messageIds?: string[] | undefined;
+        }[];
+        volumes: {
+            id: string;
+            snapshot: string;
+        }[];
+        errors?: string[] | undefined;
+    }[];
+    record: {
+        version: "spawnfile.moment-record.v1";
+        agent: string;
+        wake: {
+            at: string;
+            startedAt: string;
+            executionId: string;
+            deliveries: {
+                deliveryId: string;
+                kind: string;
+                occurredAt: string;
+            }[];
+            surface?: "moltnet" | undefined;
+            room?: string | undefined;
+            from?: string | undefined;
+            messageId?: string | undefined;
+        };
+        recordedAt: string;
+        exact: boolean;
+        resources: ({
+            id: string;
+            kind: "git";
+            commit: string;
+            sha256?: string | undefined;
+        } | {
+            id: string;
+            kind: "bundle";
+            sha256: string;
+        })[];
+        feeds: {
+            id: string;
+            revision: string;
+            tree: string;
+            landedAt: string;
+            commit?: string | undefined;
+            ref?: string | undefined;
+            paths?: string[] | undefined;
+            period?: string | undefined;
+        }[];
+        memory: {
+            id: string;
+            declaredBy: string;
+            seq: number;
+            generation?: number | undefined;
+        }[];
+        moltnet: {
+            network: string;
+            cursor: string;
+            messageIds?: string[] | undefined;
+        }[];
+        volumes: {
+            id: string;
+            snapshot: string;
+        }[];
+        errors?: string[] | undefined;
+    } | null;
+    effectiveAt: string;
+    inputs: RewindInput[];
+    selected: import("./select.js").SelectedExample;
+    at: string;
+    agentSlug: string;
+};
+/** A separately callable disk acceptance gate, also used to test deliberately broken producers. */
+export declare const finalizeTrainingMoment: (staging: string, out: string, options?: LeakCheckOptions) => Promise<MaterializedMoment>;
+/** Local-only rewind. No compilation artifacts, model invocation, auth, shell or network access. */
+export declare const materializeTrainingMoment: (options: MaterializeTrainingMomentOptions) => Promise<MaterializedMoment>;