@noopolis/daimon 0.2.0 → 0.2.1

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

@@ -1 +1 @@
-{"version":3,"file":"wakeFuse.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeFuse.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,iBAAiB,EAAG,8BAAuC,CAAC;AACzE,eAAO,MAAM,uBAAuB,EAAG,4BAAqC,CAAC;AAC7E,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAC/C,eAAO,MAAM,4BAA4B,UAAY,CAAC;AAEtD,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,eAAe,GAAG,eAAe,GAAG,oBAAoB,CAAC;AAC3G,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACxF,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,qBAAqB,EAAE,MAAM,CAAC;IAAC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC/W,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAAC,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,yBAAyB,GAAG,qBAAqB,CAAA;CAAE,CAAC,CAAC;AACtN,MAAM,MAAM,eAAe,GAAG,QAAQ,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAChC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC,CAAC;AAQH;;;;;;GAMG;AACH,qBAAa,QAAQ;IAMjB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG;IAbtB,OAAO,CAAC,MAAM,CAAoC;IAClD,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,iBAAiB,CAAS;IAElC,OAAO;WAYM,IAAI,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAqC9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,gBAAqB,GAAG,OAAO,CAAC,eAAe,CAAC;IAS7F,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,gBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IASrF,gBAAgB,IAAI,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC;IAQjE,OAAO,IAAI,kBAAkB,GAAG,SAAS;IACnC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAEd,QAAQ;YAqBR,IAAI;CAiBnB;AAED,wBAAgB,wBAAwB,CAAC,WAAW,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAG7F"}
+{"version":3,"file":"wakeFuse.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeFuse.ts"],"names":[],"mappings":"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"}

package/dist/runtime/wakeFuse.js

@@ -5,8 +5,34 @@ import { createHash, randomUUID } from "node:crypto";
 import { resolveTurnUsageLedgerPath, TURN_USAGE_LEDGER, TURN_USAGE_MAX_IDENTIFIER_CHARS, TURN_USAGE_ROTATE_BYTES } from "./turnUsageLedger.js";
 export const WAKE_FUSE_VERSION = "noopolis.daimon.wake-fuse.v1";
 export const WAKE_FUSE_DIRECTORY_ENV = "DAIMON_WAKE_FUSE_DIRECTORY";
+export const WAKE_FUSE_EPOCH_ZONE_ENV = "DAIMON_WAKE_FUSE_EPOCH_ZONE";
 export const DEFAULT_WAKE_FUSE_MAX_WAKES = 100;
 export const DEFAULT_WAKE_FUSE_MAX_TOKENS = 5_000_000;
+/**
+ * The counting window, when the operator has not named one.
+ *
+ * WHY THIS IS DERIVED AND NOT CONFIGURED
+ * --------------------------------------
+ * `DAIMON_WAKE_FUSE_EPOCH` is read from the container's env file, and an env
+ * file is applied at container CREATION only. So an operator who wants a daily
+ * budget has to rewrite that file and RECREATE THE CONTAINER every day, and
+ * the only thing that ever did that was a daily rebuild. The budget was
+ * therefore coupled to a deploy: stop deploying daily and the wake ceiling
+ * never resets, and the organization stops admitting wakes for good.
+ *
+ * A date-derived epoch removes the coupling instead of moving it. There is no
+ * file to rewrite, no deploy, no restart, and no clock for anybody to forget.
+ *
+ * An explicitly configured epoch still wins, unchanged: an operator pinning one
+ * window is doing it deliberately, and this must not roll it out from under
+ * them.
+ */
+export function derivedEpoch(organizationKey, at, zone) {
+    // `en-CA` renders ISO-8601 (YYYY-MM-DD), which is what makes this sortable
+    // and stable; the zone is what makes "a day" mean the operator's day.
+    const day = new Intl.DateTimeFormat("en-CA", { timeZone: zone, year: "numeric", month: "2-digit", day: "2-digit" }).format(at);
+    return `organization-${createHash("sha256").update(organizationKey).digest("hex")}-${day}`;
+}
 const TRIP_MARKER = "fuse.trip.json";
 let warnedDisarmed = false;
 /**
@@ -26,10 +52,11 @@ export class WakeFuse {
     admissions;
     usageLedgerPath;
     now;
+    nextEpoch;
     serial = Promise.resolve();
     reason;
     tripMarkerMissing = false;
-    constructor(armed, directory, epoch, epochStartedAt, maxWakes, maxTokens, admissions, usageLedgerPath, now) {
+    constructor(armed, directory, epoch, epochStartedAt, maxWakes, maxTokens, admissions, usageLedgerPath, now, nextEpoch) {
         this.armed = armed;
         this.directory = directory;
         this.epoch = epoch;
@@ -39,6 +66,7 @@ export class WakeFuse {
         this.admissions = admissions;
         this.usageLedgerPath = usageLedgerPath;
         this.now = now;
+        this.nextEpoch = nextEpoch;
     }
     static async open(options) {
         const environment = options.environment ?? process.env;
@@ -47,20 +75,23 @@ export class WakeFuse {
             throw new Error("DAIMON_WAKE_FUSE must be exactly 'off' when set");
         if (environment.DAIMON_WAKE_FUSE_EPOCH !== undefined && nonBlank(environment.DAIMON_WAKE_FUSE_EPOCH) === undefined)
             throw new Error("DAIMON_WAKE_FUSE_EPOCH must be non-blank");
-        const epoch = nonBlank(environment.DAIMON_WAKE_FUSE_EPOCH)
-            // Agent ids are the stable organization identity available to Daimon.
-            ?? `organization-${createHash("sha256").update(options.organizationKey).digest("hex")}`;
+        const pinned = nonBlank(environment.DAIMON_WAKE_FUSE_EPOCH);
+        const zone = nonBlank(environment[WAKE_FUSE_EPOCH_ZONE_ENV]) ?? "UTC";
+        // A pinned epoch never rolls; a derived one rolls with the operator's day.
+        // Agent ids are the stable organization identity available to Daimon.
+        const nextEpoch = (at) => pinned ?? derivedEpoch(options.organizationKey, at, zone);
         const maxWakes = ceiling(environment.DAIMON_WAKE_FUSE_MAX_WAKES, DEFAULT_WAKE_FUSE_MAX_WAKES, "DAIMON_WAKE_FUSE_MAX_WAKES");
         const maxTokens = ceiling(environment.DAIMON_WAKE_FUSE_MAX_TOKENS, DEFAULT_WAKE_FUSE_MAX_TOKENS, "DAIMON_WAKE_FUSE_MAX_TOKENS");
         const directory = resolveWakeFuseDirectory(environment);
         const now = options.now ?? (() => new Date());
+        const epoch = nextEpoch(now());
         const usageLedgerPath = resolveTurnUsageLedgerPath(environment);
         if (setting === "off") {
             if (!warnedDisarmed) {
                 warnedDisarmed = true;
                 console.error("DAIMON WAKE FUSE IS OFF: wake admission is unbounded");
             }
-            return new WakeFuse(false, directory, epoch, now().toISOString(), maxWakes, maxTokens, new Set(), usageLedgerPath, now);
+            return new WakeFuse(false, directory, epoch, now().toISOString(), maxWakes, maxTokens, new Set(), usageLedgerPath, now, nextEpoch);
         }
         // Unbounded defaults would reproduce exactly the failure this module prevents.
         await readdir(directory);
@@ -73,7 +104,7 @@ export class WakeFuse {
         const admissions = new Set(records
             .filter((record) => record.kind === "admission" && record.epoch === epoch)
             .map((record) => key(record.agent, record.delivery)));
-        const fuse = new WakeFuse(true, directory, epoch, epochStartedAt, maxWakes, maxTokens, admissions, usageLedgerPath, now);
+        const fuse = new WakeFuse(true, directory, epoch, epochStartedAt, maxWakes, maxTokens, admissions, usageLedgerPath, now, nextEpoch);
         if (await exists(path.join(directory, "fuse.stop")))
             fuse.reason = "operator_stop";
         else
@@ -89,7 +120,27 @@ export class WakeFuse {
         this.serial = result.then(() => undefined, () => undefined);
         return result;
     }
+    /**
+     * The budget as the caller should act on it NOW — which means after the day
+     * has been allowed to roll.
+     *
+     * This is the gate the scheduler actually consults: `AttentionDispatcher.drain()`
+     * returns at `snapshot().state !== "available"` before it ever reaches
+     * `admit()`. Rolling only inside `admitNow` therefore never fired for an
+     * organization that had hit its ceiling — it stayed paused across midnight
+     * and only a process restart could renew the budget. The roll is serialized
+     * with admissions so a snapshot and an admission never see two windows.
+     */
     async snapshot(agentId, limits = {}) {
+        const result = this.serial.catch(() => undefined).then(async () => {
+            if (this.armed)
+                await this.rollEpochIfDue();
+            return await this.snapshotNow(agentId, limits);
+        });
+        this.serial = result.then(() => undefined, () => undefined);
+        return await result;
+    }
+    async snapshotNow(agentId, limits = {}) {
         const used = this.admissions.size;
         const agentUsed = [...this.admissions].filter((entry) => entry.startsWith(`${bounded(agentId)}\u0000`)).length;
         const tokens = this.armed ? await sumTokens(this.usageLedgerPath, this.epochStartedAt) : 0;
@@ -111,7 +162,55 @@ export class WakeFuse {
     }
     tripped() { return this.reason; }
     async close() { await this.serial; }
+    /**
+     * Moves the counting window when the derived day has changed.
+     *
+     * Called at admission, which is the only moment the answer can matter: the
+     * organization runtime is a long-lived process, so an epoch computed once at
+     * open() would be the same epoch a week later.
+     *
+     * WHAT ROLLS AND WHAT DOES NOT
+     * ----------------------------
+     * A new window clears a CEILING trip, exactly as selecting a new epoch by
+     * hand always did: `readTripMarker` only honours a marker belonging to the
+     * current epoch. It does NOT clear an operator stop. `fuse.stop` is checked
+     * by existence and is deliberately not epoch-scoped, so a parked newsroom
+     * stays parked across midnight. That asymmetry is the whole point: a budget
+     * is a thing that renews, an operator stop is a decision that does not.
+     *
+     * Admissions are rebuilt from the ledger rather than emptied, so a clock that
+     * steps BACKWARD into a window that already spent wakes does not hand the
+     * organization a fresh budget.
+     */
+    async rollEpochIfDue() {
+        const wanted = this.nextEpoch(this.now());
+        if (wanted === this.epoch)
+            return;
+        const records = await readFuseRecords(this.directory);
+        const existingStart = records.filter((record) => record.kind === "epoch_start" && record.epoch === wanted).at(-1);
+        const startedAt = existingStart?.at ?? this.now().toISOString();
+        if (existingStart === undefined)
+            await append(this.directory, { v: WAKE_FUSE_VERSION, kind: "epoch_start", epoch: wanted, at: startedAt });
+        this.epoch = wanted;
+        this.epochStartedAt = startedAt;
+        this.admissions = new Set(records
+            .filter((record) => record.kind === "admission" && record.epoch === wanted)
+            .map((record) => key(record.agent, record.delivery)));
+        // Re-evaluate the trip for the NEW window. Clearing a CEILING is the part
+        // that does work here, and it is what makes the budget renew.
+        //
+        // The operator-stop branch is deliberately BELT AND BRACES, not the guard:
+        // `admitNow` checks `fuse.stop` itself on every admission, unscoped by
+        // epoch, and `trip()` sets the reason — so a park is already enforced
+        // whatever this line does. I could not write a failing test for it, and
+        // said so rather than dressing it up as a guarantee. It stays because it
+        // keeps the object's own state coherent at the moment it rolls; the test
+        // above pins the BEHAVIOUR, which is what must not regress.
+        this.reason = await exists(path.join(this.directory, "fuse.stop")) ? "operator_stop" : await readTripMarker(this.directory, wanted);
+    }
     async admitNow(agentId, deliveryId, limits) {
+        // Before the trip is consulted: a new day may have cleared a ceiling.
+        await this.rollEpochIfDue();
         if (this.reason !== undefined)
             return await this.trip(this.reason);
         try {
@@ -120,7 +219,7 @@ export class WakeFuse {
             const admissionKey = key(bounded(agentId), bounded(deliveryId));
             if (this.admissions.has(admissionKey))
                 return { state: "admitted" };
-            const budget = await this.snapshot(agentId, limits);
+            const budget = await this.snapshotNow(agentId, limits);
             if (budget.agent_executions_remaining === 0)
                 return { state: "paused", reason: "agent_execution_ceiling" };
             if (budget.agent_tokens_remaining === 0)

package/dist/runtime/wakeMomentFs.d.ts

@@ -0,0 +1,27 @@
+import { type FileHandle } from "node:fs/promises";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+export { WakeMomentFault } from "./wakeMomentIo.js";
+/** Diagnostics never include source paths, file contents, or arbitrary exception text. */
+export declare function wakeMomentFailure(error: unknown): string;
+export type MomentStore = {
+    verify(io: WakeMomentIo, target?: string): Promise<void>;
+    close(): Promise<void>;
+};
+/** Pin the caller's root, then re-check the same dev/ino/uid/mode at every write boundary. */
+export declare function pinMomentStore(directory: string, io: WakeMomentIo, verifyPrepared?: () => Promise<void>): Promise<MomentStore>;
+export declare function openMomentDirectory(directory: string, io?: WakeMomentIo): Promise<FileHandle>;
+export declare function ensureMomentDirectory(directory: string, io?: WakeMomentIo): Promise<void>;
+export declare function syncMomentDirectory(directory: string, io?: WakeMomentIo): Promise<void>;
+/** Refuses symlinks, special files and hard-linked metadata, including a FIFO before it can block. */
+export declare function openMomentFile(file: string, flags?: number, io?: WakeMomentIo): Promise<FileHandle>;
+export declare function manifestBytes(value: unknown, max?: number): string;
+export declare function readMomentJson(file: string, io?: WakeMomentIo, max?: number): Promise<unknown>;
+/** Unlike FileHandle.writeFile, each syscall is admitted through the cancellation fence. */
+export declare function writeMomentBytes(fd: FileHandle, bytes: string | Buffer): Promise<void>;
+export declare function writeMomentJson(file: string, bytes: string, io: WakeMomentIo, cleanup: Set<string>, verifyReplacement?: () => Promise<void>): Promise<void>;
+export declare function momentPathExists(target: string, io?: WakeMomentIo): Promise<boolean>;
+/** Never recurse until root identity AND the target's parent components have just been verified. */
+export declare function cleanMomentPaths(paths: Set<string>, store: MomentStore, io: WakeMomentIo): Promise<void>;
+/** Explicit traversal keeps recursive cleanup cancellable between individual filesystem calls. */
+export declare function removeMomentPath(target: string, store: MomentStore, io: WakeMomentIo): Promise<void>;
+//# sourceMappingURL=wakeMomentFs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentFs.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeMomentFs.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKzD,OAAO,EAAmB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIxD;AAED,MAAM,MAAM,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC;AAE/G,8FAA8F;AAC9F,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CA0BpI;AAMD,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAKzG;AAED,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrG;AAED,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnG;AAED,sGAAsG;AACtG,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,SAAqB,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CAO3H;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,GAAoC,MAAM,GAAG,MAAM,CAInG;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,eAAqB,EAAE,GAAG,GAAoC,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAiB3I;AAED,4FAA4F;AAC5F,wBAAsB,gBAAgB,CAAC,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5F;AAED,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBjK;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,eAAqB,GAAG,OAAO,CAAC,OAAO,CAAC,CAGhG;AAED,oGAAoG;AACpG,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAK9G;AAED,kGAAkG;AAClG,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAc1G"}

package/dist/runtime/wakeMomentFs.js

@@ -0,0 +1,223 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { assertNoSymlinkComponents, assertRuntimeDirectory, identity, sameIdentity } from "./physicalReadiness.js";
+import { WakeMomentFault, WakeMomentIo } from "./wakeMomentIo.js";
+export { WakeMomentFault } from "./wakeMomentIo.js";
+/** Diagnostics never include source paths, file contents, or arbitrary exception text. */
+export function wakeMomentFailure(error) {
+    if (error instanceof WakeMomentFault)
+        return error.reason;
+    const code = error?.code;
+    return ["EACCES", "EPERM", "ENOENT", "ENOSPC", "EIO", "ELOOP", "ENOTDIR", "EEXIST", "EMFILE", "ENAMETOOLONG", "EXDEV"].includes(code ?? "") ? code : "recording_io_failed";
+}
+/** Pin the caller's root, then re-check the same dev/ino/uid/mode at every write boundary. */
+export async function pinMomentStore(directory, io, verifyPrepared) {
+    await assertNoSymlinkComponents(directory, io.fs.lstat);
+    const before = await io.fs.lstat(directory);
+    assertPrivate(before);
+    // A raw handle is shared by the capture and separately bounded finalization scopes.
+    const fd = await io.call("pinStore", () => open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW));
+    const expected = identity(before);
+    const store = {
+        async verify(scope, target) {
+            try {
+                await scope.call("verifyPreparedStore", async () => { await verifyPrepared?.(); });
+                await assertNoSymlinkComponents(directory, scope.fs.lstat);
+                const entry = await scope.fs.lstat(directory);
+                const opened = await scope.call("statStore", () => fd.stat());
+                assertPrivate(entry);
+                if (!sameIdentity(expected, identity(entry)) || !sameIdentity(expected, identity(opened)))
+                    throw new Error("changed");
+                if (target?.startsWith(`${directory}${path.sep}`))
+                    await assertNoSymlinkComponents(path.dirname(target), scope.fs.lstat);
+            }
+            catch {
+                scope.check();
+                throw new WakeMomentFault("recording_store_changed");
+            }
+        },
+        close: () => fd.close()
+    };
+    try {
+        await store.verify(io);
+        return store;
+    }
+    catch (error) {
+        void fd.close().catch(() => undefined);
+        throw error;
+    }
+}
+function assertPrivate(entry) {
+    assertRuntimeDirectory(entry, "recording.directory", "private", { uid: process.getuid?.() ?? -1, gid: process.getgid?.() ?? -1 });
+}
+export async function openMomentDirectory(directory, io = new WakeMomentIo()) {
+    await assertNoSymlinkComponents(directory, io.fs.lstat);
+    const fd = await io.fs.open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        assertPrivate(await fd.stat());
+        return fd;
+    }
+    catch (error) {
+        await fd.close();
+        throw error;
+    }
+}
+export async function ensureMomentDirectory(directory, io = new WakeMomentIo()) {
+    let created = false;
+    try {
+        await io.fs.mkdir(directory, { mode: 0o700 });
+        created = true;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+    const fd = await openMomentDirectory(directory, io);
+    try {
+        await fd.sync();
+    }
+    finally {
+        await fd.close();
+    }
+    if (created)
+        await syncMomentDirectory(path.dirname(directory), io);
+}
+export async function syncMomentDirectory(directory, io = new WakeMomentIo()) {
+    const fd = await io.fs.open(directory, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        await fd.sync();
+    }
+    finally {
+        await fd.close();
+    }
+}
+/** Refuses symlinks, special files and hard-linked metadata, including a FIFO before it can block. */
+export async function openMomentFile(file, flags = constants.O_RDONLY, io = new WakeMomentIo()) {
+    const fd = await io.fs.open(file, flags | constants.O_NOFOLLOW | constants.O_NONBLOCK, 0o600);
+    try {
+        const stat = await fd.stat();
+        if (!stat.isFile() || stat.nlink !== 1)
+            throw new WakeMomentFault("invalid_metadata_file");
+        return fd;
+    }
+    catch (error) {
+        await fd.close();
+        throw error;
+    }
+}
+export function manifestBytes(value, max = WAKE_MOMENTS.maxManifestBytes) {
+    const bytes = JSON.stringify(value);
+    if (Buffer.byteLength(bytes) > Math.min(max, WAKE_MOMENTS.maxManifestBytes))
+        throw new WakeMomentFault("manifest_size_limit");
+    return bytes;
+}
+export async function readMomentJson(file, io = new WakeMomentIo(), max = WAKE_MOMENTS.maxManifestBytes) {
+    const fd = await openMomentFile(file, constants.O_RDONLY, io);
+    try {
+        const limit = Math.min(max, WAKE_MOMENTS.maxManifestBytes);
+        if ((await fd.stat()).size > limit)
+            throw new WakeMomentFault("manifest_size_limit");
+        const chunks = [];
+        let length = 0;
+        for (;;) {
+            const buffer = Buffer.alloc(Math.min(64 * 1024, limit + 1 - length));
+            const { bytesRead } = await fd.read(buffer, 0, buffer.length, null);
+            if (!bytesRead)
+                break;
+            length += bytesRead;
+            if (length > limit)
+                throw new WakeMomentFault("manifest_size_limit");
+            chunks.push(buffer.subarray(0, bytesRead));
+        }
+        return JSON.parse(Buffer.concat(chunks, length).toString("utf8"));
+    }
+    finally {
+        await fd.close();
+    }
+}
+/** Unlike FileHandle.writeFile, each syscall is admitted through the cancellation fence. */
+export async function writeMomentBytes(fd, bytes) {
+    const buffer = typeof bytes === "string" ? Buffer.from(bytes) : bytes;
+    for (let offset = 0; offset < buffer.length;) {
+        const { bytesWritten } = await fd.write(buffer, offset, Math.min(64 * 1024, buffer.length - offset), null);
+        if (!bytesWritten)
+            throw new WakeMomentFault("short_write");
+        offset += bytesWritten;
+    }
+}
+export async function writeMomentJson(file, bytes, io, cleanup, verifyReplacement) {
+    let temporary;
+    do {
+        temporary = `${file}.${randomUUID()}.tmp`;
+    } while (await momentPathExists(temporary, io));
+    const fd = await openMomentFile(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, io);
+    cleanup.add(temporary); // Exclusive creation, never the name alone, establishes cleanup ownership.
+    try {
+        await writeMomentBytes(fd, bytes);
+        await fd.sync();
+        await fd.close();
+        let reservation;
+        try {
+            reservation = await openMomentFile(file, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, io);
+            cleanup.add(file);
+        }
+        catch (error) {
+            if (!verifyReplacement || error.code !== "EEXIST")
+                throw error;
+            await verifyReplacement(); // The caller must establish ownership before replacement.
+            reservation = await openMomentFile(file, constants.O_RDONLY, io);
+        }
+        await reservation.close();
+        await io.fs.rename(temporary, file);
+        cleanup.delete(temporary);
+        await syncMomentDirectory(path.dirname(file), io);
+    }
+    finally {
+        await fd.close();
+    }
+}
+export async function momentPathExists(target, io = new WakeMomentIo()) {
+    try {
+        await io.fs.lstat(target);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+/** Never recurse until root identity AND the target's parent components have just been verified. */
+export async function cleanMomentPaths(paths, store, io) {
+    for (const target of paths) {
+        await removeMomentPath(target, store, io);
+        paths.delete(target);
+    }
+}
+/** Explicit traversal keeps recursive cleanup cancellable between individual filesystem calls. */
+export async function removeMomentPath(target, store, io) {
+    await store.verify(io, target);
+    let entry;
+    try {
+        entry = await io.fs.lstat(target);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (entry.isDirectory()) {
+        await assertNoSymlinkComponents(target, io.fs.lstat);
+        for await (const child of await io.fs.opendir(target))
+            await removeMomentPath(path.join(target, child.name), store, io);
+        await store.verify(io, target);
+        await io.fs.rmdir(target);
+    }
+    else {
+        await store.verify(io, target);
+        await io.fs.unlink(target);
+    }
+}

package/dist/runtime/wakeMomentHistory.d.ts

@@ -0,0 +1,26 @@
+import { WakeMomentIo } from "./wakeMomentIo.js";
+export declare const SNAPSHOT_NAME: RegExp;
+export declare const snapshotRootName: (id: string) => string;
+declare const INDEX_VERSION = "noopolis.daimon.wake-latest.v1";
+export type SnapshotIndex = {
+    version: typeof INDEX_VERSION;
+    snapshot: string;
+    oldest: string | null;
+};
+export declare function snapshotName(startedAt: string, executionId: string): string;
+export declare function snapshotTime(name: string): number;
+/** Eligibility precedes BOTH base selection and retention protection, not only deletion. */
+export declare function eligibleSnapshot(directory: string, name: string, io: WakeMomentIo, rollback?: ReadonlySet<string>): Promise<boolean>;
+/** Only a missing/invalid index or an expired oldest name requires history enumeration. */
+export declare function completeSnapshotNames(directory: string, io?: WakeMomentIo, rollback?: ReadonlySet<string>): Promise<string[]>;
+export declare function indexFromNames(names: string[]): SnapshotIndex | undefined;
+export declare function latestSnapshotIndex(directory: string, io: WakeMomentIo, rollback?: ReadonlySet<string>): Promise<{
+    index?: SnapshotIndex;
+    names?: string[];
+}>;
+/** Called after manifest publication, before the marker: a crash leaves an invalid index,
+ * never a valid stale pointer hiding a newer complete snapshot. Clock rollback keeps the newer base. */
+export declare function indexWithSnapshot(previous: SnapshotIndex | undefined, name: string): SnapshotIndex;
+export declare function writeSnapshotIndex(directory: string, index: SnapshotIndex, io: WakeMomentIo, cleanup: Set<string>): Promise<void>;
+export {};
+//# sourceMappingURL=wakeMomentHistory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentHistory.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeMomentHistory.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAElE,eAAO,MAAM,aAAa,QAAyC,CAAC;AACpE,eAAO,MAAM,gBAAgB,GAAI,IAAI,MAAM,KAAG,MAAoE,CAAC;AACnH,QAAA,MAAM,aAAa,mCAAmC,CAAC;AAEvD,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,OAAO,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAEvG,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAG3E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED,4FAA4F;AAC5F,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAU1I;AAED,2FAA2F;AAC3F,wBAAsB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,eAAqB,EAAE,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAczI;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa,GAAG,SAAS,CAEzE;AAUD,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;IAAE,KAAK,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAOnK;AAED;wGACwG;AACxG,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,aAAa,CAMlG;AAED,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CASvI"}

package/dist/runtime/wakeMomentHistory.js

@@ -0,0 +1,109 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { readMomentJson, writeMomentJson } from "./wakeMomentFs.js";
+import { WakeMomentFault, WakeMomentIo } from "./wakeMomentIo.js";
+export const SNAPSHOT_NAME = /^\d{8}T\d{9}Z-[A-Za-z0-9._-]{1,200}$/;
+export const snapshotRootName = (id) => id === "." || id === ".." ? id.replaceAll(".", "%2E") : id;
+const INDEX_VERSION = "noopolis.daimon.wake-latest.v1";
+const INDEX_BYTES = 1024;
+export function snapshotName(startedAt, executionId) {
+    const execution = /^[A-Za-z0-9._-]{1,128}$/.test(executionId) ? executionId : `sha256-${createHash("sha256").update(executionId).digest("hex")}`;
+    return `${startedAt.replace(/[-:.]/g, "")}-${execution}`;
+}
+export function snapshotTime(name) {
+    if (!SNAPSHOT_NAME.test(name))
+        return NaN;
+    const value = `${name.slice(0, 4)}-${name.slice(4, 6)}-${name.slice(6, 8)}T${name.slice(9, 11)}:${name.slice(11, 13)}:${name.slice(13, 15)}.${name.slice(15, 18)}Z`;
+    const time = Date.parse(value);
+    return Number.isFinite(time) && new Date(time).toISOString() === value ? time : NaN;
+}
+/** Eligibility precedes BOTH base selection and retention protection, not only deletion. */
+export async function eligibleSnapshot(directory, name, io, rollback) {
+    if (!Number.isFinite(snapshotTime(name)))
+        return false;
+    const target = path.join(directory, name);
+    if ([target, `${target}.manifest.json`, `${target}${WAKE_MOMENTS.completionSuffix}`].some((file) => rollback?.has(file)))
+        return false;
+    try {
+        const entry = await io.fs.lstat(target), manifest = await io.fs.lstat(`${target}.manifest.json`);
+        const marker = await io.fs.lstat(`${target}${WAKE_MOMENTS.completionSuffix}`);
+        return entry.isDirectory() && manifest.isFile() && manifest.nlink === 1
+            && marker.isFile() && marker.size === 0 && marker.nlink === 1;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+/** Only a missing/invalid index or an expired oldest name requires history enumeration. */
+export async function completeSnapshotNames(directory, io = new WakeMomentIo(), rollback) {
+    const names = [];
+    try {
+        for await (const entry of await io.fs.opendir(directory)) {
+            if (entry.isDirectory() && await eligibleSnapshot(directory, entry.name, io, rollback))
+                names.push(entry.name);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    names.sort((a, b) => snapshotTime(b) - snapshotTime(a) || b.localeCompare(a));
+    // Timestamp ties use publication metadata; no historical manifest contents are read.
+    const stamps = new Map();
+    for (let i = 0; i < names.length; i++)
+        if (snapshotTime(names[i]) === snapshotTime(names[i - 1] ?? "") || snapshotTime(names[i]) === snapshotTime(names[i + 1] ?? "")) {
+            stamps.set(names[i], (await io.fs.lstat(path.join(directory, `${names[i]}.manifest.json`), { bigint: true })).mtimeNs);
+        }
+    return names.sort((a, b) => snapshotTime(b) - snapshotTime(a) || ((stamps.get(a) ?? 0n) < (stamps.get(b) ?? 0n) ? 1 : (stamps.get(a) ?? 0n) > (stamps.get(b) ?? 0n) ? -1 : b.localeCompare(a)));
+}
+export function indexFromNames(names) {
+    return names[0] ? { version: INDEX_VERSION, snapshot: names[0], oldest: names.length > 1 ? names[names.length - 1] : null } : undefined;
+}
+function isSnapshotIndex(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).length !== 3)
+        return false;
+    const index = value;
+    return index.version === INDEX_VERSION && typeof index.snapshot === "string" && Number.isFinite(snapshotTime(index.snapshot))
+        && (index.oldest === null || (typeof index.oldest === "string" && index.oldest !== index.snapshot
+            && Number.isFinite(snapshotTime(index.oldest)) && snapshotTime(index.oldest) <= snapshotTime(index.snapshot)));
+}
+export async function latestSnapshotIndex(directory, io, rollback) {
+    try {
+        const value = await readMomentJson(path.join(directory, "latest"), io, INDEX_BYTES);
+        if (isSnapshotIndex(value) && await eligibleSnapshot(directory, value.snapshot, io, rollback))
+            return { index: value };
+    }
+    catch {
+        io.check(); /* The bounded index is a cache; recover from missing/damaged metadata. */
+    }
+    const names = await completeSnapshotNames(directory, io, rollback);
+    return { index: indexFromNames(names), names };
+}
+/** Called after manifest publication, before the marker: a crash leaves an invalid index,
+ * never a valid stale pointer hiding a newer complete snapshot. Clock rollback keeps the newer base. */
+export function indexWithSnapshot(previous, name) {
+    if (!previous)
+        return { version: INDEX_VERSION, snapshot: name, oldest: null };
+    const newest = snapshotTime(name) >= snapshotTime(previous.snapshot) ? name : previous.snapshot;
+    const others = [previous.oldest, newest === name ? previous.snapshot : name].filter((entry) => entry !== null);
+    others.sort((a, b) => snapshotTime(a) - snapshotTime(b));
+    return { version: INDEX_VERSION, snapshot: newest, oldest: others[0] };
+}
+export async function writeSnapshotIndex(directory, index, io, cleanup) {
+    const target = path.join(directory, "latest");
+    await writeMomentJson(target, JSON.stringify(index), io, cleanup, async () => {
+        let owned = false;
+        try {
+            owned = isSnapshotIndex(await readMomentJson(target, io, INDEX_BYTES));
+        }
+        catch {
+            io.check();
+        }
+        if (!owned)
+            throw new WakeMomentFault("invalid_latest_index");
+    });
+    cleanup.delete(target);
+}

package/dist/runtime/wakeMomentIo.d.ts

@@ -0,0 +1,22 @@
+import * as fs from "node:fs/promises";
+export declare class WakeMomentFault extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+/** Internal fault-injection seam, never configuration or a public runtime export. */
+export type WakeMomentIoProbe = (operation: string, target?: string, entries?: number) => void | Promise<void>;
+/** Every filesystem call checks cancellation before issuing I/O and after it settles. */
+export declare class WakeMomentIo {
+    private readonly probe?;
+    readonly fs: typeof fs;
+    verifyWrite?: (target?: string) => Promise<void>;
+    private aborted;
+    private expires;
+    constructor(probe?: WakeMomentIoProbe | undefined);
+    check(): void;
+    call<T>(operation: string, action: () => Promise<T>, target?: string): Promise<T>;
+    bounded<T>(milliseconds: number, action: () => Promise<T>): Promise<T>;
+    private handle;
+    private directory;
+}
+//# sourceMappingURL=wakeMomentIo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentIo.d.ts","sourceRoot":"","sources":["../../src/runtime/wakeMomentIo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAKvC,qBAAa,eAAgB,SAAQ,KAAK;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;CACpC;AAED,qFAAqF;AACrF,MAAM,MAAM,iBAAiB,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/G,yFAAyF;AACzF,qBAAa,YAAY;IAMX,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;IALnC,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAY;gBAEE,KAAK,CAAC,EAAE,iBAAiB,YAAA;IAgBtD,KAAK,IAAI,IAAI;IAOP,IAAI,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAoBjF,OAAO,CAAC,CAAC,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAa5E,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,SAAS;CAkBlB"}