@noopolis/daimon 0.2.0 → 0.2.2

package/dist/runtime/wakeAcceptanceStore.js

@@ -1,3 +1,4 @@
+import { WakeExecutionClaimLostError, readExpectedClaim, waitForClaimTransitionLock } from "./wakeAcceptanceClaimDiagnostics.js";
 import { sameNamespace, currentProcessIdentity, processIsAlive, WakeTransitionLockBlockedError } from "./wakeAcceptanceProcessIdentity.js";
 import { constants } from "node:fs";
 import { link, lstat, open, readFile, readdir, realpath, rename, unlink } from "node:fs/promises";
@@ -6,8 +7,9 @@ import { createHash, randomUUID } from "node:crypto";
 import { MAX_WAKE_ACCEPTANCE_RECORD_BYTES, sanitizeWakeCompletionText, wakeAcceptanceDigest } from "./wakeAcceptanceTypes.js";
 import { sanitizeExecutionError, parseStoredWakeAcceptance, publicStatus } from "./wakeAcceptanceRecord.js";
 import { assertOfflineReconciliationLeaseAvailable } from "./wakeAcceptanceReconciliation.js";
-import { acquireHostRegistration, releaseHostRegistration } from "./storeCoordination.js";
-import { MAX_WAKE_ACCEPTANCE_RECORDS, terminalFilesToCompact } from "./wakeAcceptanceRetention.js";
+import { acquireHostRegistration, pruneDeadHostRegistrations, releaseHostRegistration } from "./storeCoordination.js";
+import { WakeAcceptanceIndex } from "./wakeAcceptanceIndex.js";
+import { MAX_WAKE_ACCEPTANCE_RECORDS, WAKE_ACCEPTANCE_COMPACTION_THRESHOLD, staleQueuedFilesToStop, terminalFilesToCompact } from "./wakeAcceptanceRetention.js";
 const DEFAULT_CLAIM_TTL_MS = 240_000;
 /** Durable, private idempotency authority; callers must pre-create its 0700 root. */
 export class WakeAcceptanceStore {
@@ -21,7 +23,9 @@ export class WakeAcceptanceStore {
     ownerLiveness;
     afterFinalLockAssertion;
     mutations = Promise.resolve();
-    acceptanceFiles = new Map();
+    index;
+    onRecordRead;
+    claimTransitionLockTiming;
     constructor(root, directory, identity, registration, claimTtlMs, now, owner, ownerLiveness, afterFinalLockAssertion) {
         this.root = root;
         this.directory = directory;
@@ -32,6 +36,8 @@ export class WakeAcceptanceStore {
         this.owner = owner;
         this.ownerLiveness = ownerLiveness;
         this.afterFinalLockAssertion = afterFinalLockAssertion;
+        this.index = new WakeAcceptanceIndex(root, { directoryStat: async () => await this.directory.stat({ bigint: true }), files: async () => await this.files(), readId: async (file) => (await this.read(file)).acceptance_id, fileStat: async (file) => await lstat(file, { bigint: true }).catch((error) => { if (error.code === "ENOENT")
+                return undefined; throw error; }) }, () => BigInt(this.now()) * 1000000n);
     }
     static async open(root, options = {}) {
         const claimTtlMs = options.claimTtlMs ?? DEFAULT_CLAIM_TTL_MS;
@@ -53,23 +59,27 @@ export class WakeAcceptanceStore {
             if (!same(identity(before), identity(after)))
                 throw new Error("wake acceptance store changed during validation");
             const registration = await acquireHostRegistration(real, directory, owner);
-            return new WakeAcceptanceStore(real, directory, identity(before), registration, claimTtlMs, options.nowForTest ?? Date.now, owner, options.ownerLiveness ?? processIsAlive, options.afterFinalLockAssertion);
+            await pruneDeadHostRegistrations(real, directory, registration, options.ownerLiveness ?? processIsAlive);
+            const store = new WakeAcceptanceStore(real, directory, identity(before), registration, claimTtlMs, options.nowForTest ?? Date.now, owner, options.ownerLiveness ?? processIsAlive, options.afterFinalLockAssertion);
+            store.claimTransitionLockTiming = options.claimTransitionLockTimingForTest;
+            store.onRecordRead = options.onRecordReadForTest;
+            return store;
         }
         catch (error) {
             await directory.close().catch(() => undefined);
             throw error;
         }
     }
-    accept(request) {
-        return this.serialize(async () => await this.acceptNow(request));
+    accept(request, nativeSchedule = false) {
+        return this.serialize(async () => await this.acceptNow(request, nativeSchedule));
     }
-    async acceptNow(request) {
+    async acceptNow(request, nativeSchedule) {
         await this.verify();
         const request_digest = wakeAcceptanceDigest(request);
         const target = this.fileFor(request.agent_id, request.delivery_id);
         const existing = await this.readOptional(target);
         if (existing !== undefined) {
-            if (existing.request_digest !== request_digest)
+            if (existing.request_digest !== request_digest || existing.native_schedule !== (nativeSchedule ? true : undefined))
                 throw new WakeAcceptanceConflictError();
             return { record: existing, created: false };
         }
@@ -77,7 +87,7 @@ export class WakeAcceptanceStore {
         if ((await this.files()).length >= MAX_WAKE_ACCEPTANCE_RECORDS)
             throw new WakeInboxFullError();
         const now = new Date().toISOString();
-        const record = { acceptance_id: randomUUID(), agent_id: request.agent_id, delivery_id: request.delivery_id, request_digest, event: request.event, state: "accepted", accepted_at: now, updated_at: now };
+        const record = { acceptance_id: randomUUID(), agent_id: request.agent_id, delivery_id: request.delivery_id, request_digest, event: request.event, state: "accepted", accepted_at: now, updated_at: now, ...(nativeSchedule ? { native_schedule: true } : {}) };
         const temporary = path.join(this.root, `.pending-${randomUUID()}`);
         try {
             await this.writeNew(temporary, record);
@@ -88,12 +98,12 @@ export class WakeAcceptanceStore {
                 if (error.code !== "EEXIST")
                     throw error;
                 const winner = await this.read(target);
-                if (winner.request_digest !== request_digest)
+                if (winner.request_digest !== request_digest || winner.native_schedule !== (nativeSchedule ? true : undefined))
                     throw new WakeAcceptanceConflictError();
                 return { record: winner, created: false };
             }
             await this.directory.sync();
-            this.acceptanceFiles.set(record.acceptance_id, target);
+            this.index.set(record.acceptance_id, target);
             return { record, created: true };
         }
         finally {
@@ -123,7 +133,7 @@ export class WakeAcceptanceStore {
                 ...(includeExecutionErrors && record.execution_error !== undefined ? { execution_error: record.execution_error } : {}) };
         });
     }
-    async recoverable(agentIds) {
+    async recoverable(agentIds, onStale) {
         const result = [];
         for (const file of await this.files()) {
             const record = await this.read(path.join(this.root, file));
@@ -131,7 +141,12 @@ export class WakeAcceptanceStore {
                 throw new Error("wake acceptance store contains an unknown agent authority");
             if (record.state === "accepted" || record.state === "running") {
                 const claim = await this.readClaimOptional(this.claimFor(record));
-                result.push(!record.deferred && record.execution_id === undefined && claim?.acceptance_ids?.includes(record.acceptance_id) && claim.execution_id !== undefined ? { ...record, execution_id: claim.execution_id } : record);
+                // A long-parked delivery is no longer offered: it would head every batch ahead of today's mail. Compaction stops it.
+                if (staleQueuedFilesToStop([{ file, state: record.state, updatedAt: record.updated_at, acceptedAt: record.accepted_at, acceptanceId: record.acceptance_id, claimed: claim !== undefined && !expired(claim, this.now()) }], this.now()).length) {
+                    onStale?.(record);
+                    continue;
+                }
+                result.push(!record.deferred && record.execution_id === undefined && record.execution_error === undefined && claim?.acceptance_ids?.includes(record.acceptance_id) && claim.execution_id !== undefined ? { ...record, execution_id: claim.execution_id } : record);
             }
         }
         return result.sort((left, right) => left.accepted_at.localeCompare(right.accepted_at) || left.acceptance_id.localeCompare(right.acceptance_id));
@@ -140,13 +155,14 @@ export class WakeAcceptanceStore {
         return this.serialize(async () => await this.transitionNow(acceptanceId, state, code));
     }
     /** Fuse race seam: never stops a record that was claimed after enumeration. */
-    transitionAcceptedToStopped(acceptanceId) {
+    transitionAcceptedToStopped(acceptanceId, code = "host_stopping") {
         return this.serialize(async () => {
             const target = await this.pathForAcceptanceId(acceptanceId);
             const prior = await this.read(target);
-            if (prior.state !== "accepted")
+            const claim = prior.state === "accepted" ? await this.readClaimOptional(this.claimFor(prior)) : undefined;
+            if (prior.state !== "accepted" || (claim !== undefined && !expired(claim, this.now())))
                 return prior;
-            const record = { ...prior, state: "stopped", code: "host_stopping", updated_at: new Date().toISOString() };
+            const record = { ...prior, state: "stopped", code, updated_at: new Date().toISOString() };
             await this.replace(target, record);
             return record;
         });
@@ -216,13 +232,9 @@ export class WakeAcceptanceStore {
             const record = await this.findByAcceptanceId(acceptanceId);
             if (record === undefined)
                 throw new Error("wake acceptance receipt is unavailable");
-            const lock = await this.acquireTransitionLock(record, claim.owner_id);
-            if (lock === undefined)
-                throw new WakeExecutionClaimLostError();
+            const lock = await waitForClaimTransitionLock(() => this.acquireTransitionLock(record, claim.owner_id), () => this.readLockOptional(this.lockFor(record)), acceptanceId, claim, "renew", this.claimTransitionLockTiming);
             try {
-                const current = await this.readClaim(this.claimFor(record));
-                if (!(current.acceptance_id === acceptanceId || current.acceptance_ids?.includes(acceptanceId)) || current.acceptance_id !== claim.acceptance_id || current.owner_id !== claim.owner_id || current.generation !== claim.generation || current.expires_at !== claim.expires_at || expired(current, this.now()))
-                    throw new WakeExecutionClaimLostError();
+                const current = await readExpectedClaim(() => this.readClaim(this.claimFor(record)), acceptanceId, claim, "renew", this.now, lock);
                 const renewed = { ...current, expires_at: new Date(this.now() + this.claimTtlMs).toISOString() };
                 await this.replaceValue(this.claimFor(record), renewed);
                 return renewed;
@@ -240,24 +252,22 @@ export class WakeAcceptanceStore {
             const initial = await this.findByAcceptanceId(acceptanceId);
             if (initial === undefined)
                 throw new Error("wake acceptance receipt is unavailable");
-            const lock = await this.acquireTransitionLock(initial, claim.owner_id);
-            if (lock === undefined)
-                throw new WakeExecutionClaimLostError();
+            const lock = await waitForClaimTransitionLock(() => this.acquireTransitionLock(initial, claim.owner_id), () => this.readLockOptional(this.lockFor(initial)), acceptanceId, claim, `transition:${state}`, this.claimTransitionLockTiming);
             try {
-                let record = await this.transitionNowClaimed(acceptanceId, claim);
+                let record = await this.transitionNowClaimed(acceptanceId, claim, `transition:${state}:initial`, lock);
                 if (isTerminal(record.state))
                     return record;
                 if (state !== "running" && record.claim_generation !== claim.generation)
-                    throw new WakeExecutionClaimLostError();
-                await this.assertTransitionLock(record, lock);
-                record = await this.transitionNowClaimed(acceptanceId, claim);
+                    throw new WakeExecutionClaimLostError({ step: `transition:${state}`, assertion: "record_claim_generation", acceptance_id: acceptanceId, expected: claim.generation, current: record.claim_generation ?? null, lock });
+                await this.assertTransitionLock(record, lock, `transition:${state}`);
+                record = await this.transitionNowClaimed(acceptanceId, claim, `transition:${state}:final`, lock);
                 if (isTerminal(record.state))
                     return record;
                 if (state !== "running" && record.claim_generation !== claim.generation)
-                    throw new WakeExecutionClaimLostError();
-                await this.assertTransitionLock(record, lock);
+                    throw new WakeExecutionClaimLostError({ step: `transition:${state}`, assertion: "record_claim_generation", acceptance_id: acceptanceId, expected: claim.generation, current: record.claim_generation ?? null, lock });
+                await this.assertTransitionLock(record, lock, `transition:${state}`);
                 await this.afterFinalLockAssertion?.();
-                await this.assertTransitionLock(record, lock);
+                await this.assertTransitionLock(record, lock, `transition:${state}:before_write`);
                 const target = this.fileFor(record.agent_id, record.delivery_id);
                 // The code explains the transition that produced the CURRENT state, so a
                 // transition that names none clears it. While codes existed only on terminal
@@ -285,14 +295,12 @@ export class WakeAcceptanceStore {
         return this.serialize(async () => {
             const record = await this.findByAcceptanceId(claim.acceptance_id);
             if (!record)
-                throw new WakeExecutionClaimLostError();
-            const lock = await this.acquireTransitionLock(record, claim.owner_id);
-            if (!lock)
-                throw new WakeExecutionClaimLostError();
+                throw new WakeExecutionClaimLostError({ step: "release", assertion: "record_missing", acceptance_id: claim.acceptance_id, expected: claim, current: null });
+            const lock = await waitForClaimTransitionLock(() => this.acquireTransitionLock(record, claim.owner_id), () => this.readLockOptional(this.lockFor(record)), claim.acceptance_id, claim, "release", this.claimTransitionLockTiming);
             try {
                 const current = await this.readClaimOptional(this.claimFor(record));
                 if (current?.generation !== claim.generation || current.owner_id !== claim.owner_id)
-                    throw new WakeExecutionClaimLostError();
+                    throw new WakeExecutionClaimLostError({ step: "release", assertion: "claim_identity", acceptance_id: claim.acceptance_id, expected: claim, current: current ?? null, lock });
                 await unlink(this.claimFor(record));
                 await this.directory.sync();
             }
@@ -329,16 +337,8 @@ export class WakeAcceptanceStore {
     async findByAcceptanceId(acceptanceId) {
         if (!uuid(acceptanceId))
             return undefined;
-        const known = this.acceptanceFiles.get(acceptanceId);
-        if (known !== undefined)
-            return await this.readOptional(known);
-        for (const file of await this.files()) {
-            const record = await this.read(path.join(this.root, file));
-            this.acceptanceFiles.set(record.acceptance_id, path.join(this.root, file));
-            if (record.acceptance_id === acceptanceId)
-                return record;
-        }
-        return undefined;
+        await this.verify();
+        return await this.index.find(acceptanceId, async (file) => await this.readOptional(file));
     }
     async pathForAcceptanceId(acceptanceId) {
         const record = await this.findByAcceptanceId(acceptanceId);
@@ -352,7 +352,7 @@ export class WakeAcceptanceStore {
         const target = this.lockFor(record);
         const current = await this.readLockOptional(target);
         if (current !== undefined && !sameNamespace(current, this.owner))
-            throw new WakeTransitionLockBlockedError();
+            throw new WakeTransitionLockBlockedError({ step: "acquire_transition_lock", acceptance_id: record.acceptance_id, expected: this.owner, current });
         if (current !== undefined && await this.ownerLiveness(current))
             return undefined;
         if (current !== undefined) {
@@ -378,10 +378,10 @@ export class WakeAcceptanceStore {
             await unlink(temporary).catch(() => undefined);
         }
     }
-    async assertTransitionLock(record, lock) {
-        const current = await this.readLock(this.lockFor(record)).catch(() => { throw new WakeExecutionClaimLostError(); });
+    async assertTransitionLock(record, lock, step) {
+        const current = await this.readLock(this.lockFor(record)).catch((cause) => { throw new WakeExecutionClaimLostError({ step, assertion: "transition_lock_read", acceptance_id: record.acceptance_id, expected: lock, current: null }, cause); });
         if (current.owner_id !== lock.owner_id || current.generation !== lock.generation || current.pid !== lock.pid || current.process_start !== lock.process_start || current.boot_id !== lock.boot_id || !sameNamespace(current, lock))
-            throw new WakeExecutionClaimLostError();
+            throw new WakeExecutionClaimLostError({ step, assertion: "transition_lock_identity", acceptance_id: record.acceptance_id, expected: lock, current });
     }
     async releaseTransitionLock(record, lock) {
         const target = this.lockFor(record);
@@ -399,7 +399,7 @@ export class WakeAcceptanceStore {
         const entries = await readdir(this.root);
         const files = entries.filter((entry) => /^[a-f0-9]{64}\.json$/.test(entry));
         if (files.length > MAX_WAKE_ACCEPTANCE_RECORDS || entries.length > MAX_WAKE_ACCEPTANCE_RECORDS + 128)
-            throw new Error("wake acceptance store exceeds its bounded record limit");
+            throw new WakeInboxFullError("wake acceptance store exceeds its bounded record limit");
         return files;
     }
     async claimFiles() { return (await readdir(this.root)).filter((entry) => /^[a-f0-9]{64}\.agent-claim$/.test(entry)); }
@@ -415,6 +415,7 @@ export class WakeAcceptanceStore {
         const entry = await lstat(file);
         if (!entry.isFile() || entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 0o777) !== 0o600 || entry.size > MAX_WAKE_ACCEPTANCE_RECORD_BYTES)
             throw new Error("wake acceptance record is unsafe");
+        this.onRecordRead?.(file);
         const bytes = await readFile(file);
         if (bytes.length > MAX_WAKE_ACCEPTANCE_RECORD_BYTES)
             throw new Error("wake acceptance record exceeds its bound");
@@ -471,25 +472,29 @@ export class WakeAcceptanceStore {
             throw new Error("wake transition lock is invalid");
         return result;
     }
-    async transitionNowClaimed(acceptanceId, claim) {
+    async transitionNowClaimed(acceptanceId, claim, step, lock) {
         const record = await this.findByAcceptanceId(acceptanceId);
         if (record === undefined)
             throw new Error("wake acceptance receipt is unavailable");
-        const current = await this.readClaim(this.claimFor(record));
-        if (!(current.acceptance_id === acceptanceId || current.acceptance_ids?.includes(acceptanceId)) || current.acceptance_id !== claim.acceptance_id || current.owner_id !== claim.owner_id || current.generation !== claim.generation || current.expires_at !== claim.expires_at || expired(current, this.now()))
-            throw new WakeExecutionClaimLostError();
+        await readExpectedClaim(() => this.readClaim(this.claimFor(record)), acceptanceId, claim, step, this.now, lock);
         return record;
     }
     async compactTerminalRecords() {
         const files = await this.files();
-        if (files.length < 2_112)
+        if (files.length < WAKE_ACCEPTANCE_COMPACTION_THRESHOLD)
             return;
         const records = await Promise.all(files.map(async (file) => ({ file, record: await this.read(path.join(this.root, file)) })));
+        const candidates = await Promise.all(records.map(async ({ file, record }) => ({ file, state: record.state, updatedAt: record.updated_at, acceptedAt: record.accepted_at, acceptanceId: record.acceptance_id, claimed: await this.readClaimOptional(this.claimFor(record)).then((claim) => claim !== undefined && !expired(claim, this.now())) })));
+        for (const file of staleQueuedFilesToStop(candidates, this.now())) {
+            const entry = records.find((candidate) => candidate.file === file);
+            entry.record = { ...entry.record, state: "stopped", code: "queued_wake_stopped", updated_at: new Date(this.now()).toISOString() };
+            await this.replace(path.join(this.root, file), entry.record);
+        }
         for (const file of terminalFilesToCompact(records.map(({ file, record }) => ({ file, state: record.state, updatedAt: record.updated_at, acceptanceId: record.acceptance_id })))) {
             const record = records.find((candidate) => candidate.file === file)?.record;
-            if (record !== undefined)
-                this.acceptanceFiles.delete(record.acceptance_id);
             await unlink(path.join(this.root, file));
+            if (record !== undefined)
+                this.index.forget(path.join(this.root, file));
         }
         await this.directory.sync();
     }
@@ -524,14 +529,12 @@ export class WakeAcceptanceStore {
     }
 }
 export class WakeInboxFullError extends Error {
-    constructor() { super("wake acceptance store has no capacity without deleting active work"); }
+    constructor(message = "wake acceptance store has no capacity without deleting active work") { super(message); }
 }
 export class WakeAcceptanceConflictError extends Error {
     constructor() { super("delivery id is already bound to a different request"); }
 }
-export class WakeExecutionClaimLostError extends Error {
-    constructor() { super("wake execution claim was lost"); }
-}
+export { WakeExecutionClaimLostError, WakeTransitionLockContentionError } from "./wakeAcceptanceClaimDiagnostics.js";
 /** A container boundary requires deployment-authorized offline reconciliation. */
 export { WakeTransitionLockBlockedError } from "./wakeAcceptanceProcessIdentity.js";
 export { publicAcceptance } from "./wakeAcceptanceRecord.js";

package/dist/runtime/wakeFuse.d.ts

@@ -1,5 +1,6 @@
 export declare const WAKE_FUSE_VERSION: "noopolis.daimon.wake-fuse.v1";
 export declare const WAKE_FUSE_DIRECTORY_ENV: "DAIMON_WAKE_FUSE_DIRECTORY";
+export declare const WAKE_FUSE_EPOCH_ZONE_ENV: "DAIMON_WAKE_FUSE_EPOCH_ZONE";
 export declare const DEFAULT_WAKE_FUSE_MAX_WAKES = 100;
 export declare const DEFAULT_WAKE_FUSE_MAX_TOKENS = 5000000;
 export type WakeFuseTripReason = "wake_ceiling" | "token_ceiling" | "operator_stop" | "ledger_unavailable";
@@ -30,6 +31,26 @@ export type WakeFuseVerdict = Readonly<{
     state: "paused";
     reason: "agent_execution_ceiling" | "agent_token_ceiling";
 }>;
+/**
+ * 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 declare function derivedEpoch(organizationKey: string, at: Date, zone: string): string;
 export type WakeFuseOptions = Readonly<{
     organizationKey: string;
     environment?: NodeJS.ProcessEnv;
@@ -45,23 +66,57 @@ export type WakeFuseOptions = Readonly<{
 export declare class WakeFuse {
     private readonly armed;
     private readonly directory;
-    private readonly epoch;
-    private readonly epochStartedAt;
+    private epoch;
+    private epochStartedAt;
     private readonly maxWakes;
     private readonly maxTokens;
-    private readonly admissions;
+    private admissions;
     private readonly usageLedgerPath;
     private readonly now;
+    private readonly nextEpoch;
     private serial;
     private reason;
     private tripMarkerMissing;
     private constructor();
     static open(options: WakeFuseOptions): Promise<WakeFuse>;
     admit(agentId: string, deliveryId: string, limits?: WakeBudgetLimits): Promise<WakeFuseVerdict>;
+    /**
+     * 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.
+     */
     snapshot(agentId: string, limits?: WakeBudgetLimits): Promise<WakeBudgetSnapshot>;
+    private snapshotNow;
     pollOperatorStop(): Promise<WakeFuseTripReason | undefined>;
     tripped(): WakeFuseTripReason | undefined;
     close(): Promise<void>;
+    /**
+     * 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.
+     */
+    private rollEpochIfDue;
     private admitNow;
     private trip;
 }

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"}