@noopolis/daimon 0.2.0 → 0.2.2

package/dist/runtime/wakeMomentRetention.js

@@ -0,0 +1,143 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import path from "node:path";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { cleanMomentPaths, openMomentDirectory, openMomentFile, pinMomentStore, removeMomentPath, syncMomentDirectory, writeMomentBytes } from "./wakeMomentFs.js";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+import { momentLines } from "./wakeMomentRows.js";
+import { completeSnapshotNames, eligibleSnapshot, indexFromNames, latestSnapshotIndex, snapshotRootName, snapshotTime, writeSnapshotIndex } from "./wakeMomentHistory.js";
+const sweeps = new Map();
+const key = (snapshot) => `${snapshot.id}/${snapshot.snapshot}`;
+function expiredRow(line, agentId, cutoff, current) {
+    try {
+        const row = JSON.parse(line.toString("utf8"));
+        if (current && row.execution_id === current.execution_id && row.started_at === current.started_at)
+            return undefined;
+        if (row?.version === WAKE_MOMENTS.version && row.agent_id === agentId && typeof row.execution_id === "string"
+            && Array.isArray(row.deliveries) && Array.isArray(row.snapshots) && typeof row.started_at === "string"
+            && new Date(row.started_at).toISOString() === row.started_at && Date.parse(row.started_at) < cutoff)
+            return row;
+    }
+    catch { /* Unknown/partial lines are not ours to delete. */ }
+    return undefined;
+}
+/** First-line age check; a full sweep every 64 calls also handles foreign prefixes/clock rollback. */
+export async function pruneWakeMoments(recording, agentId, now = Date.now(), current, scope, authority) {
+    const io = scope ?? new WakeMomentIo();
+    const store = authority ?? await pinMomentStore(recording.directory, io);
+    io.verifyWrite = (target) => store.verify(io, target);
+    try {
+        const cutoff = now - recording.keepMs;
+        await pruneSnapshots(recording.directory, new Set(current?.snapshots.map(key) ?? []), cutoff, io, store);
+        await pruneRows(recording, agentId, cutoff, current, io, store);
+    }
+    finally {
+        if (!authority)
+            await store.close();
+    }
+}
+async function pruneRows(recording, agentId, cutoff, current, io, store) {
+    const target = path.join(recording.directory, WAKE_MOMENTS.rowsFile);
+    let source;
+    try {
+        source = await openMomentFile(target, constants.O_RDONLY, io);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    const temporary = `${target}.${randomUUID()}.tmp`;
+    let output, changed = false, created = false;
+    try {
+        const count = (sweeps.get(target) ?? 0) + 1;
+        sweeps.set(target, count % 64);
+        let firstExpired = false;
+        for await (const line of momentLines(source)) {
+            firstExpired = expiredRow(line, agentId, cutoff, current) !== undefined;
+            break;
+        }
+        if (!firstExpired && count % 64 !== 0)
+            return;
+        output = await openMomentFile(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, io);
+        created = true;
+        const reread = await openMomentFile(target, constants.O_RDONLY, io);
+        try {
+            for await (const line of momentLines(reread)) {
+                const expired = expiredRow(line, agentId, cutoff, current);
+                if (!expired) {
+                    await writeMomentBytes(output, line);
+                    continue;
+                }
+                changed = true;
+            }
+        }
+        finally {
+            await reread.close();
+        }
+        if (!changed)
+            return;
+        await output.sync();
+        await output.close();
+        output = undefined;
+        await io.fs.rename(temporary, target);
+        created = false;
+        await syncMomentDirectory(recording.directory, io);
+    }
+    finally {
+        await source.close();
+        await output?.close();
+        if (created)
+            await removeMomentPath(temporary, store, io);
+    }
+}
+/** Age comes from names; ownership comes from the writer's zero-byte completion marker. */
+async function pruneSnapshots(directory, protectedSnapshots, cutoff, io, store) {
+    const namespace = path.join(directory, WAKE_MOMENTS.snapshotsDirectory);
+    try {
+        const ns = await openMomentDirectory(namespace, io);
+        await ns.close();
+        for await (const root of await io.fs.opendir(namespace)) {
+            if (!root.isDirectory() || !/^(?:[A-Za-z0-9._-]{1,128}|%2E|%2E%2E)$/.test(root.name))
+                continue;
+            const id = root.name === "%2E" ? "." : root.name === "%2E%2E" ? ".." : root.name;
+            if (snapshotRootName(id) !== root.name)
+                continue;
+            const base = path.join(namespace, root.name);
+            const fd = await openMomentDirectory(base, io);
+            await fd.close();
+            const state = await latestSnapshotIndex(base, io);
+            if (!state.names && (state.index.oldest === null || snapshotTime(state.index.oldest) >= cutoff))
+                continue;
+            const names = state.names ?? await completeSnapshotNames(base, io), removed = new Set();
+            for (const name of names.slice(1)) {
+                if (protectedSnapshots.has(`${id}/${name}`) || snapshotTime(name) >= cutoff)
+                    continue;
+                const target = path.join(base, name), manifest = `${target}.manifest.json`, marker = `${target}${WAKE_MOMENTS.completionSuffix}`;
+                await store.verify(io, target);
+                if (!await eligibleSnapshot(base, name, io))
+                    continue;
+                await store.verify(io, target);
+                await removeMomentPath(target, store, io);
+                await removeMomentPath(manifest, store, io);
+                await removeMomentPath(marker, store, io);
+                await syncMomentDirectory(base, io);
+                removed.add(name);
+            }
+            const index = indexFromNames(names.filter((name) => !removed.has(name)));
+            if (index) {
+                const cleanup = new Set();
+                try {
+                    await writeSnapshotIndex(base, index, io, cleanup);
+                }
+                finally {
+                    await cleanMomentPaths(cleanup, store, io);
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}

package/dist/runtime/wakeMomentRows.d.ts

@@ -0,0 +1,8 @@
+import type { FileHandle } from "node:fs/promises";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+import type { WakeMomentRow } from "./wakeMomentRecorder.js";
+/** One append write and fsync. A torn prior append is delimited, never mistaken for this attempt. */
+export declare function appendWakeMomentRow(directory: string, row: WakeMomentRow, io?: WakeMomentIo): Promise<void>;
+/** Bound memory even when a damaged/foreign rows file has no newlines. */
+export declare function momentLines(fd: FileHandle): AsyncGenerator<Buffer>;
+//# sourceMappingURL=wakeMomentRows.d.ts.map

package/dist/runtime/wakeMomentRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentRows.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeMomentRows.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,qGAAqG;AACrG,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBvH;AAED,0EAA0E;AAC1E,wBAAuB,WAAW,CAAC,EAAE,EAAE,UAAU,GAAG,cAAc,CAAC,MAAM,CAAC,CAmBzE"}

package/dist/runtime/wakeMomentRows.js

@@ -0,0 +1,66 @@
+import { constants } from "node:fs";
+import path from "node:path";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { openMomentFile, syncMomentDirectory, WakeMomentFault } from "./wakeMomentFs.js";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+/** One append write and fsync. A torn prior append is delimited, never mistaken for this attempt. */
+export async function appendWakeMomentRow(directory, row, io = new WakeMomentIo()) {
+    const line = Buffer.from(`${JSON.stringify(row)}\n`);
+    if (line.length > WAKE_MOMENTS.maxRowBytes)
+        throw new WakeMomentFault("row_size_limit");
+    const target = path.join(directory, WAKE_MOMENTS.rowsFile);
+    let created = false, fd;
+    try {
+        fd = await openMomentFile(target, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | constants.O_APPEND, io);
+        created = true;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        fd = await openMomentFile(target, constants.O_RDWR | constants.O_APPEND, io);
+    }
+    try {
+        const size = (await fd.stat()).size;
+        const tail = Buffer.alloc(1);
+        if (size)
+            await fd.read(tail, 0, 1, size - 1);
+        const bytes = size && tail[0] !== 10 ? Buffer.concat([Buffer.from("\n"), line]) : line;
+        const { bytesWritten } = await fd.write(bytes);
+        if (bytesWritten !== bytes.length)
+            throw new WakeMomentFault("short_row_write");
+        await fd.sync();
+        if (created)
+            await syncMomentDirectory(directory, io);
+    }
+    finally {
+        await fd.close();
+    }
+}
+/** Bound memory even when a damaged/foreign rows file has no newlines. */
+export async function* momentLines(fd) {
+    const chunk = Buffer.alloc(64 * 1024);
+    let pending = [], length = 0;
+    for (;;) {
+        const { bytesRead } = await fd.read(chunk, 0, chunk.length, null);
+        if (!bytesRead)
+            break;
+        let start = 0;
+        while (start < bytesRead) {
+            const newline = chunk.indexOf(10, start);
+            const end = newline >= start && newline < bytesRead ? newline + 1 : bytesRead;
+            const part = Buffer.from(chunk.subarray(start, end));
+            length += part.length;
+            if (length > WAKE_MOMENTS.maxRowBytes)
+                throw new WakeMomentFault("row_size_limit");
+            pending.push(part);
+            if (part[part.length - 1] === 10) {
+                yield Buffer.concat(pending, length);
+                pending = [];
+                length = 0;
+            }
+            start = end;
+        }
+    }
+    if (length)
+        yield Buffer.concat(pending, length);
+}

package/dist/runtime/wakeMomentSnapshot.d.ts

@@ -0,0 +1,56 @@
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+export { completeSnapshotNames, snapshotName, snapshotRootName, snapshotTime } from "./wakeMomentHistory.js";
+type Identity = {
+    dev: string;
+    ino: string;
+    size: string;
+    mtimeNs: string;
+    ctimeNs: string;
+    mode: number;
+};
+export type SnapshotEntry = {
+    type: "file" | "directory" | "symlink";
+    mode: number;
+    size: string;
+    source: Identity;
+    target?: string;
+};
+export type WakeSnapshotManifest = {
+    version: typeof WAKE_MOMENTS.version;
+    id: string;
+    snapshot: string;
+    started_at: string;
+    sourcePath: string;
+    entries: Record<string, SnapshotEntry>;
+};
+export type WakeSnapshot = {
+    id: string;
+    snapshot: string;
+    files: number;
+    copied: number;
+    linked: number;
+    skipped: number;
+};
+export declare function readSnapshotManifest(directory: string, name: string, id: string, io?: WakeMomentIo, maxManifestBytes?: number): Promise<WakeSnapshotManifest | undefined>;
+/** SOURCE identity, never the copied inode's metadata: ordinary writers cannot restore ctime. */
+export declare function sameSnapshotSource(left: Identity, right: Identity): boolean;
+type CaptureInput = {
+    directory: string;
+    root: {
+        id: string;
+        path: string;
+    };
+    startedAt: string;
+    executionId: string;
+    /** Internal test bounds; not caller configuration. */
+    maxEntries?: number;
+    maxManifestBytes?: number;
+    io?: WakeMomentIo;
+    cleanup?: Set<string>;
+};
+export declare function captureWakeSnapshot(input: CaptureInput): Promise<{
+    snapshot: WakeSnapshot;
+    note?: string;
+}>;
+//# sourceMappingURL=wakeMomentSnapshot.d.ts.map

package/dist/runtime/wakeMomentSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentSnapshot.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeMomentSnapshot.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAIlE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAE,qBAAqB,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE7G,KAAK,QAAQ,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3G,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtI,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,OAAO,YAAY,CAAC,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAC3G,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,YAAY,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAC5H,wBAAsB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,eAAqB,EAAE,gBAAgB,GAAoC,MAAM,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAQtN;AAED,iGAAiG;AACjG,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAG3E;AAKD,KAAK,YAAY,GAAG;IAClB,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAC9F,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC/C,EAAE,CAAC,EAAE,YAAY,CAAC;IAAC,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC1C,CAAC;AAEF,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAkBjH"}

package/dist/runtime/wakeMomentSnapshot.js

@@ -0,0 +1,248 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import path from "node:path";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { assertNoSymlinkComponents } from "./physicalReadiness.js";
+import { cleanMomentPaths, ensureMomentDirectory, manifestBytes, momentPathExists, openMomentFile, pinMomentStore, readMomentJson, syncMomentDirectory, WakeMomentFault, writeMomentJson } from "./wakeMomentFs.js";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+import { indexWithSnapshot, latestSnapshotIndex, snapshotName, snapshotRootName, snapshotTime, writeSnapshotIndex } from "./wakeMomentHistory.js";
+export { completeSnapshotNames, snapshotName, snapshotRootName, snapshotTime } from "./wakeMomentHistory.js";
+export async function readSnapshotManifest(directory, name, id, io = new WakeMomentIo(), maxManifestBytes = WAKE_MOMENTS.maxManifestBytes) {
+    try {
+        const value = await readMomentJson(path.join(directory, `${name}.manifest.json`), io, maxManifestBytes);
+        if (!value || value.version !== WAKE_MOMENTS.version || value.id !== id || value.snapshot !== name || Date.parse(value.started_at) !== snapshotTime(name)
+            || typeof value.sourcePath !== "string" || !value.entries || typeof value.entries !== "object" || Array.isArray(value.entries)
+            || Object.keys(value.entries).length > WAKE_MOMENTS.maxSnapshotEntries)
+            return undefined;
+        return value;
+    }
+    catch {
+        io.check();
+        return undefined;
+    }
+}
+/** SOURCE identity, never the copied inode's metadata: ordinary writers cannot restore ctime. */
+export function sameSnapshotSource(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size
+        && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs && left.mode === right.mode;
+}
+function identity(stat) {
+    return { dev: String(stat.dev), ino: String(stat.ino), size: String(stat.size), mtimeNs: String(stat.mtimeNs), ctimeNs: String(stat.ctimeNs), mode: Number(stat.mode) };
+}
+export async function captureWakeSnapshot(input) {
+    if (input.io && input.cleanup)
+        return capture(input, input.io, input.cleanup);
+    const io = new WakeMomentIo(), cleanup = new Set();
+    let store;
+    try {
+        return await io.bounded(WAKE_MOMENTS.captureDeadlineMs, async () => {
+            store = await pinMomentStore(input.directory, io);
+            io.verifyWrite = (target) => store.verify(io, target);
+            return capture(input, io, cleanup);
+        });
+    }
+    finally {
+        if (store) {
+            const finalizer = new WakeMomentIo();
+            finalizer.verifyWrite = (target) => store.verify(finalizer, target);
+            try {
+                await finalizer.bounded(WAKE_MOMENTS.finalizationDeadlineMs, () => cleanMomentPaths(cleanup, store, finalizer));
+            }
+            finally {
+                void store.close().catch(() => undefined);
+            }
+        }
+    }
+}
+async function capture(input, io, cleanup) {
+    const namespace = path.join(input.directory, WAKE_MOMENTS.snapshotsDirectory);
+    await ensureMomentDirectory(namespace, io);
+    const base = path.join(namespace, snapshotRootName(input.root.id));
+    await ensureMomentDirectory(base, io);
+    const requestedName = snapshotName(input.startedAt, input.executionId);
+    let name = requestedName;
+    while (await collides(name))
+        name = `${requestedName}-${randomUUID()}`;
+    const partial = path.join(base, `${name}.partial`), destination = path.join(base, name);
+    const { index } = await latestSnapshotIndex(base, io, cleanup), previousName = index?.snapshot;
+    let previous = previousName ? await readSnapshotManifest(base, previousName, input.root.id, io, input.maxManifestBytes) : undefined;
+    if (previous?.sourcePath !== input.root.path)
+        previous = undefined;
+    const manifest = { version: WAKE_MOMENTS.version, id: input.root.id, snapshot: name, started_at: input.startedAt, sourcePath: input.root.path, entries: Object.create(null) };
+    const snapshot = { id: input.root.id, snapshot: name, files: 0, copied: 0, linked: 0, skipped: 0 };
+    const max = Math.min(input.maxEntries ?? WAKE_MOMENTS.maxSnapshotEntries, WAKE_MOMENTS.maxSnapshotEntries);
+    let entries = 0, note;
+    await io.fs.mkdir(partial, { mode: 0o700 });
+    cleanup.add(partial);
+    {
+        let root;
+        try {
+            await assertNoSymlinkComponents(input.root.path, io.fs.lstat);
+            root = await openSourceDirectory(input.root.path, io);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                note = "root_missing";
+            else
+                throw error;
+        }
+        if (root) {
+            try {
+                await walk(root, input.root.path, "");
+            }
+            finally {
+                await root.close();
+            }
+        }
+        // The writer enforces exactly the reader's byte bound BEFORE either publication rename.
+        const bytes = manifestBytes(manifest, input.maxManifestBytes);
+        await syncMomentDirectory(partial, io);
+        // Reserve the final name exclusively before rename can replace anything at it.
+        await io.fs.mkdir(destination, { mode: 0o700 });
+        cleanup.add(destination);
+        await io.fs.rename(partial, destination);
+        cleanup.delete(partial);
+        await syncMomentDirectory(base, io);
+        const manifestPath = path.join(base, `${name}.manifest.json`);
+        await writeMomentJson(manifestPath, bytes, io, cleanup);
+        try {
+            await writeSnapshotIndex(base, indexWithSnapshot(index, name), io, cleanup);
+        }
+        catch (error) {
+            if (!(error instanceof WakeMomentFault) || error.reason !== "invalid_latest_index")
+                throw error;
+            note = [note, error.reason].filter(Boolean).join("; ");
+        }
+        const markerPath = path.join(base, `${name}${WAKE_MOMENTS.completionSuffix}`);
+        const marker = await openMomentFile(markerPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, io);
+        cleanup.add(markerPath);
+        try {
+            await marker.sync();
+        }
+        finally {
+            await marker.close();
+        }
+        await syncMomentDirectory(base, io);
+        cleanup.delete(markerPath);
+        cleanup.delete(manifestPath);
+        cleanup.delete(destination);
+        return { snapshot, ...(note ? { note } : {}) };
+    }
+    async function collides(candidate) {
+        for (const suffix of ["", ".partial", ".manifest.json", WAKE_MOMENTS.completionSuffix]) {
+            if (await momentPathExists(path.join(base, `${candidate}${suffix}`), io))
+                return true;
+        }
+        return false; // Temporary metadata names are separately checked and exclusively created.
+    }
+    async function walk(directory, source, relative) {
+        // Linux's descriptor-relative paths pin ancestors against a concurrent rename/symlink swap.
+        const anchored = process.platform === "linux" ? `/proc/self/fd/${directory.fd}` : source;
+        const expected = await directory.stat({ bigint: true });
+        await checkSourceDirectory(directory, source, expected, io);
+        for await (const entry of await io.fs.opendir(anchored)) {
+            await checkSourceDirectory(directory, source, expected, io);
+            if (++entries > max)
+                throw new WakeMomentFault("snapshot_entry_limit");
+            const rel = relative ? `${relative}/${entry.name}` : entry.name;
+            const from = path.join(anchored, entry.name), to = path.join(partial, rel);
+            const stat = await io.fs.lstat(from, { bigint: true }), sourceIdentity = identity(stat);
+            await checkSourceDirectory(directory, source, expected, io);
+            if (stat.isDirectory()) {
+                const child = await openSourceDirectory(from, io, stat);
+                try {
+                    await io.fs.mkdir(to, { mode: 0o700 });
+                    manifest.entries[rel] = { type: "directory", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity };
+                    await walk(child, from, rel);
+                    await syncMomentDirectory(to, io);
+                }
+                finally {
+                    await child.close();
+                }
+            }
+            else if (stat.isSymbolicLink()) {
+                const target = await io.fs.readlink(from);
+                await io.fs.symlink(target, to);
+                manifest.entries[rel] = { type: "symlink", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity, target };
+            }
+            else if (stat.isFile()) {
+                const sourceFile = await io.fs.open(from, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+                try {
+                    if (!sameSnapshotSource(sourceIdentity, identity(await sourceFile.stat({ bigint: true }))))
+                        throw new WakeMomentFault("source_changed");
+                    await checkSourceDirectory(directory, source, expected, io);
+                    const prior = previous && Object.hasOwn(previous.entries, rel) ? previous.entries[rel] : undefined;
+                    if (prior?.type === "file" && prior.source && sameSnapshotSource(prior.source, sourceIdentity)) {
+                        const old = path.join(base, previous.snapshot, rel);
+                        await assertNoSymlinkComponents(path.dirname(old), io.fs.lstat);
+                        if (!(await io.fs.lstat(old)).isFile())
+                            throw new WakeMomentFault("invalid_link_base");
+                        await io.fs.link(old, to);
+                        snapshot.linked++;
+                    }
+                    else {
+                        await copyFile(sourceFile, to, stat, io);
+                        snapshot.copied++;
+                    }
+                    if (!sameSnapshotSource(sourceIdentity, identity(await sourceFile.stat({ bigint: true }))))
+                        throw new WakeMomentFault("source_changed");
+                    manifest.entries[rel] = { type: "file", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity };
+                    snapshot.files++;
+                }
+                finally {
+                    await sourceFile.close();
+                }
+            }
+            else
+                snapshot.skipped++;
+        }
+        await checkSourceDirectory(directory, source, expected, io);
+    }
+}
+async function openSourceDirectory(source, io, before) {
+    if (process.platform !== "linux" || !source.startsWith("/proc/self/fd/"))
+        await assertNoSymlinkComponents(source, io.fs.lstat);
+    before ??= await io.fs.lstat(source, { bigint: true });
+    const fd = await io.fs.open(source, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        await checkSourceDirectory(fd, source, before, io);
+        return fd;
+    }
+    catch (error) {
+        await fd.close();
+        throw error;
+    }
+}
+async function checkSourceDirectory(directory, source, before, io) {
+    const opened = await directory.stat({ bigint: true }), current = await io.fs.lstat(source, { bigint: true });
+    if (![before, opened, current].every((stat) => stat.isDirectory() && stat.dev === before.dev && stat.ino === before.ino)) {
+        throw new WakeMomentFault("source_changed");
+    }
+}
+async function copyFile(source, target, stat, io) {
+    if (stat.size > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new WakeMomentFault("source_size_limit");
+    const output = await io.fs.open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        const buffer = Buffer.alloc(1024 * 1024);
+        let position = 0;
+        while (position < Number(stat.size)) {
+            const { bytesRead } = await source.read(buffer, 0, Math.min(buffer.length, Number(stat.size) - position), position);
+            if (!bytesRead)
+                throw new WakeMomentFault("source_changed");
+            let written = 0;
+            while (written < bytesRead) {
+                const result = await output.write(buffer, written, bytesRead - written, position + written);
+                if (!result.bytesWritten)
+                    throw new WakeMomentFault("short_write");
+                written += result.bytesWritten;
+            }
+            position += bytesRead;
+        }
+        await output.chmod(Number(stat.mode) & 0o777);
+        await output.sync();
+    }
+    finally {
+        await output.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noopolis/daimon",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Noopolis native per-agent runtime harness built on Pi.",
   "license": "MIT",
   "type": "module",
@@ -33,7 +33,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/noopolis/daimon.git"
+    "url": "git+ssh://git@github.com/noopolis/daimon-harness.git"
   },
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
     "clean": "rm -rf dist",
     "prepack": "npm run build",
     "prepublishOnly": "npm run typecheck && npm test",
-    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project scripts/tsconfig.json --noEmit",
+    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project scripts/tsconfig.json --noEmit && tsc --project .github/scripts/ci/tsconfig.json",
     "verify:contract-manifest": "node --import tsx scripts/emitRuntimeContractManifest.ts --check",
     "verify:native": "node --experimental-strip-types src/runtime/native/verifyArtifacts.ts",
     "verify:production-closure": "node --experimental-strip-types scripts/verifyProductionClosure.ts",
@@ -65,7 +65,7 @@
     "@earendil-works/pi-ai": "^0.79.10",
     "@earendil-works/pi-coding-agent": "^0.79.10",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@noopolis/mneme": "^0.1.1",
+    "@noopolis/mneme": "^0.1.3",
     "ajv": "^8.17.1",
     "zod": "^4.4.3"
   },