@ouro.bot/cli 0.1.0-alpha.856 → 0.1.0-alpha.857

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.857",
+      "changes": [
+        "The daemon now caches external-event records by file stat so the one-second reconcile tick no longer re-reads and re-parses every unchanged record, cutting idle CPU.",
+        "The record cache never keeps a filesystem read error and re-reads any entry older than a minute, so a transient read failure or a missed change cannot hide a record."
+      ]
+    },
     {
       "version": "0.1.0-alpha.856",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.856",
+  "runtimeVersion": "0.1.0-alpha.857",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.856</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.857</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/heart/daemon/daemon.js

@@ -637,6 +637,7 @@ class OuroDaemon {
     externalEventRoot;
     privilegedEventSpoolRoot;
     privilegedEventScanner;
+    externalEventScanCache = new router_1.ExternalEventScanCache();
     rsvpHabitRunner;
     nativeHabitRunner;
     nativeHabitMatch;
@@ -1701,12 +1702,11 @@ class OuroDaemon {
             if (fs.existsSync(this.privilegedEventSpoolRoot)) {
                 this.privilegedEventScanner({ spoolRoot: this.privilegedEventSpoolRoot, eventRoot: this.externalEventRootPath() });
             }
-            const statuses = (0, router_1.listExternalEventStatus)(this.externalEventRootPath());
+            const scanned = this.externalEventScanCache.scan(this.externalEventRootPath());
             const readinessKeys = new Set();
-            for (const status of statuses) {
-                if (status.corrupt)
+            for (const { record: candidate } of scanned) {
+                if (!candidate)
                     continue;
-                const candidate = (0, router_1.readExternalEventRecord)(status.recordPath);
                 if (candidate.dispatchEnabled === false)
                     continue;
                 const retryDue = candidate.executionState === "retry_wait" && candidate.nextAttemptAt !== null && Date.parse(candidate.nextAttemptAt) <= Date.parse(now);
@@ -1739,10 +1739,10 @@ class OuroDaemon {
             const providerEvidenceByAgent = new Map();
             const runtimeEvidenceByAgent = new Map();
             const recoveredByClass = new Map();
-            for (const status of statuses) {
-                if (status.corrupt)
+            for (const { record: scannedRecord } of scanned) {
+                if (!scannedRecord)
                     continue;
-                let record = (0, router_1.readExternalEventRecord)(status.recordPath);
+                let record = scannedRecord;
                 if (record.dispatchEnabled === false)
                     continue;
                 if (blockedReadinessKeys.has(`${record.agent}\0${record.source}`))

package/dist/heart/external-events/router.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalEventScanCache = void 0;
 exports.getExternalEventRoot = getExternalEventRoot;
 exports.externalEventRecordPath = externalEventRecordPath;
 exports.readExternalEventRecord = readExternalEventRecord;
@@ -622,6 +623,78 @@ function listExternalEventStatus(root) {
     }
     return rows.sort((left, right) => left.agent.localeCompare(right.agent) || left.source.localeCompare(right.source) || left.eventId.localeCompare(right.eventId));
 }
+/**
+ * Stat-keyed record cache for the daemon's reconcile tick. Records are written by atomic rename, so any write
+ * changes inode, mtime or ctime and invalidates the entry. Cached records are only used to decide what is due;
+ * every mutation (claim, revive, reconcile) re-reads the file under its own lock and compare-and-swap check, so a
+ * stale cached record can at worst cause one rejected attempt that the next tick retries from fresh data.
+ * As a backstop against a change the stat key misses, an entry older than `maxAgeMs` is re-read anyway, and a
+ * filesystem read error (one carrying an fs `code`, such as EIO or EMFILE) is reported for this scan but never
+ * cached, so a transient failure cannot hide a healthy record until its file next changes.
+ */
+class ExternalEventScanCache {
+    entries = new Map();
+    maxAgeMs;
+    now;
+    constructor(options = {}) {
+        this.maxAgeMs = options.maxAgeMs ?? 60_000;
+        this.now = options.now ?? Date.now;
+    }
+    scan(root) {
+        const seen = new Set();
+        const rows = [];
+        const nowMs = this.now();
+        if (fs.existsSync(root)) {
+            for (const agent of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!agent.isDirectory() || agent.name.startsWith("."))
+                    continue;
+                const agentPath = path.join(root, agent.name);
+                for (const source of fs.readdirSync(agentPath, { withFileTypes: true })) {
+                    if (!source.isDirectory() || source.name.startsWith("."))
+                        continue;
+                    const sourcePath = path.join(agentPath, source.name);
+                    for (const file of fs.readdirSync(sourcePath, { withFileTypes: true })) {
+                        if (!file.isFile() || file.name.startsWith(".") || !file.name.endsWith(".json"))
+                            continue;
+                        const recordPath = path.join(sourcePath, file.name);
+                        let stat;
+                        try {
+                            stat = fs.statSync(recordPath);
+                        }
+                        catch {
+                            continue;
+                        }
+                        seen.add(recordPath);
+                        const cached = this.entries.get(recordPath);
+                        if (cached && cached.ino === stat.ino && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs && cached.ctimeMs === stat.ctimeMs && nowMs - cached.cachedAtMs < this.maxAgeMs) {
+                            rows.push(cached.entry);
+                            continue;
+                        }
+                        let entry;
+                        let cacheable = true;
+                        try {
+                            entry = { recordPath, record: readExternalEventRecord(recordPath), error: null };
+                        }
+                        catch (error) {
+                            entry = { recordPath, record: null, error: error instanceof Error ? error.message : /* v8 ignore next -- filesystem and JSON parsers throw Error objects @preserve */ String(error) };
+                            cacheable = !(error && typeof error === "object" && typeof error.code === "string");
+                        }
+                        if (cacheable)
+                            this.entries.set(recordPath, { ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, cachedAtMs: nowMs, entry });
+                        else
+                            this.entries.delete(recordPath);
+                        rows.push(entry);
+                    }
+                }
+            }
+        }
+        for (const key of this.entries.keys())
+            if (!seen.has(key))
+                this.entries.delete(key);
+        return rows;
+    }
+}
+exports.ExternalEventScanCache = ExternalEventScanCache;
 function readExisting(recordPath) {
     if (!fs.existsSync(recordPath))
         return { record: null, corruptDuplicateCount: 0 };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.856",
+  "version": "0.1.0-alpha.857",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.856",
+      "version": "0.1.0-alpha.857",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.856",
+  "version": "0.1.0-alpha.857",
   "engines": {
     "node": ">=22"
   },