@ouro.bot/cli 0.1.0-alpha.663 → 0.1.0-alpha.664

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_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.664",
+      "changes": [
+        "Coalesce unchanged periodic Arc Sentinel daemon-health receipts so healthy daemons do not keep synced bundles dirty."
+      ]
+    },
     {
       "version": "0.1.0-alpha.663",
       "changes": [

package/dist/heart/context-loss-sentinel.js

@@ -126,6 +126,103 @@ function compareReceiptOrder(left, right) {
 function shouldReplaceReceipt(existing, candidate) {
     return existing === null || compareReceiptOrder(candidate, existing) >= 0;
 }
+function orderFromReceipt(receipt) {
+    return { generatedAt: receipt.generatedAt, id: receipt.id };
+}
+function compareOrder(left, right) {
+    const leftTime = Date.parse(left.generatedAt);
+    const rightTime = Date.parse(right.generatedAt);
+    if (leftTime !== rightTime)
+        return leftTime - rightTime;
+    return left.id.localeCompare(right.id);
+}
+function maxOrder(left, right) {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    return compareOrder(left, right) >= 0 ? left : right;
+}
+function isOrder(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.generatedAt === "string"
+        && isValidTimestamp(record.generatedAt)
+        && typeof record.id === "string";
+}
+function sentinelWatermarkPath(agentRoot) {
+    return path.join(agentRoot, "state", "arc", "context-loss-sentinel-watermark.json");
+}
+function readWatermark(agentRoot) {
+    const filePath = sentinelWatermarkPath(agentRoot);
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return {
+            schemaVersion: 1,
+            latest: isOrder(parsed.latest) ? parsed.latest : null,
+            latestReady: isOrder(parsed.latestReady) ? parsed.latestReady : null,
+        };
+    }
+    catch {
+        return { schemaVersion: 1, latest: null, latestReady: null };
+    }
+}
+function writeWatermark(agentRoot, watermark) {
+    atomicWriteJson(sentinelWatermarkPath(agentRoot), watermark);
+}
+function updateWatermarkOrder(watermark, key, candidate) {
+    watermark[key] = maxOrder(watermark[key], orderFromReceipt(candidate));
+}
+function stableReceiptState(receipt) {
+    return JSON.stringify({
+        verdict: receipt.verdict,
+        summary: receipt.summary,
+        latestReadyLocator: receipt.latestReadyLocator,
+        recoveryAnchor: receipt.recoveryAnchor,
+        gauntlet: receipt.gauntlet,
+        signals: receipt.signals,
+        resumeSnapshot: receipt.resumeSnapshot,
+    });
+}
+function sameRecoveryState(left, right) {
+    return stableReceiptState(left) === stableReceiptState(right);
+}
+function setReceiptFileMtime(filePath, receipt) {
+    const timestamp = new Date(receipt.generatedAt);
+    fs.utimesSync(filePath, timestamp, timestamp);
+}
+function selectLatestReadyReceipt(existingReady, candidate, latestReadyOrder) {
+    if (candidate.verdict !== "ready")
+        return existingReady;
+    if (latestReadyOrder && compareOrder(orderFromReceipt(candidate), latestReadyOrder) < 0)
+        return existingReady;
+    return candidate;
+}
+function shouldReplaceLatestReceipt(existingLatest, candidate, latestOrder) {
+    if (latestOrder && compareOrder(orderFromReceipt(candidate), latestOrder) < 0)
+        return false;
+    if (!existingLatest)
+        return true;
+    return shouldReplaceReceipt(existingLatest, candidate);
+}
+function coalescedDaemonHealthReceipt(agentRoot, existingLatest, existingReady, candidate, watermark) {
+    if (candidate.trigger !== "daemon_health")
+        return null;
+    if (!existingLatest || !sameRecoveryState(existingLatest, candidate))
+        return null;
+    if (candidate.verdict === "ready" && (!existingReady || !sameRecoveryState(existingReady, candidate)))
+        return null;
+    const candidateOrder = orderFromReceipt(candidate);
+    if (watermark.latest && compareOrder(candidateOrder, watermark.latest) <= 0)
+        return existingLatest;
+    updateWatermarkOrder(watermark, "latest", candidate);
+    if (candidate.verdict === "ready" && existingReady) {
+        updateWatermarkOrder(watermark, "latestReady", candidate);
+    }
+    writeWatermark(agentRoot, watermark);
+    return existingLatest;
+}
 function readJson(filePath) {
     try {
         return { ok: true, value: JSON.parse(fs.readFileSync(filePath, "utf-8")) };
@@ -619,26 +716,38 @@ function recordBlockedReceiptEvent(agentRoot, receipt) {
 }
 async function persistReceipt(agentRoot, receipt, lockTimeoutMs) {
     const paths = contextLossSentinelPaths(agentRoot);
-    await withFileLock(paths.lock, lockTimeoutMs, async () => {
+    return withFileLock(paths.lock, lockTimeoutMs, async () => {
         ensureSentinelDirs(paths);
         const existingLatest = readReceiptFile(paths.latest, "latest.json", []);
         const existingReady = readLatestReady(agentRoot);
-        const nextReady = receipt.verdict === "ready" && shouldReplaceReceipt(existingReady, receipt)
-            ? receipt
-            : existingReady;
+        const watermark = readWatermark(agentRoot);
+        const latestOrder = maxOrder(maxOrder(maxOrder(existingLatest ? orderFromReceipt(existingLatest) : null, existingReady ? orderFromReceipt(existingReady) : null), watermark.latest), watermark.latestReady);
+        const latestReadyOrder = maxOrder(maxOrder(existingReady ? orderFromReceipt(existingReady) : null, watermark.latestReady), existingLatest?.verdict === "ready" ? orderFromReceipt(existingLatest) : null);
+        const nextReady = selectLatestReadyReceipt(existingReady, receipt, latestReadyOrder);
         syncLatestReadyState(receipt, nextReady);
+        const coalesced = coalescedDaemonHealthReceipt(agentRoot, existingLatest, existingReady, receipt, watermark);
+        if (coalesced)
+            return coalesced;
         atomicWriteJson(path.join(paths.receiptsDir, `${receipt.id}.json`), receipt);
         appendHistory(paths, receipt);
-        if (shouldReplaceReceipt(existingLatest, receipt)) {
+        if (shouldReplaceLatestReceipt(existingLatest, receipt, latestOrder)) {
             atomicWriteJson(paths.latest, receipt);
+            updateWatermarkOrder(watermark, "latest", receipt);
+            writeWatermark(agentRoot, watermark);
+            setReceiptFileMtime(paths.latest, receipt);
             recordBlockedReceiptEvent(agentRoot, receipt);
         }
-        else if (existingLatest && receipt.verdict === "ready") {
-            atomicWriteJson(paths.latest, syncLatestReadyState(existingLatest, nextReady));
+        else if (existingLatest && nextReady === receipt) {
+            const updatedLatest = syncLatestReadyState(existingLatest, nextReady);
+            atomicWriteJson(paths.latest, updatedLatest);
         }
         if (receipt.verdict === "ready" && nextReady === receipt) {
             atomicWriteJson(paths.latestReady, receipt);
+            updateWatermarkOrder(watermark, "latestReady", receipt);
+            writeWatermark(agentRoot, watermark);
+            setReceiptFileMtime(paths.latestReady, receipt);
         }
+        return receipt;
     });
 }
 async function refreshContextLossSentinel(agentName, agentRoot, options) {
@@ -647,7 +756,7 @@ async function refreshContextLossSentinel(agentName, agentRoot, options) {
     if (options.delayBeforeWriteMs && options.delayBeforeWriteMs > 0) {
         await sleep(options.delayBeforeWriteMs);
     }
-    await persistReceipt(agentRoot, receipt, options.lockTimeoutMs ?? 5_000);
+    const persistedReceipt = await persistReceipt(agentRoot, receipt, options.lockTimeoutMs ?? 5_000);
     (0, runtime_1.emitNervesEvent)({
         component: "engine",
         event: "engine.context_loss_sentinel_refreshed",
@@ -655,13 +764,13 @@ async function refreshContextLossSentinel(agentName, agentRoot, options) {
         meta: {
             agentName,
             trigger: options.trigger,
-            verdict: receipt.verdict,
-            receiptId: receipt.id,
-            blockedSignals: receipt.signals.filter((entry) => entry.verdictImpact === "blocked").map((entry) => entry.id),
-            watchSignals: receipt.signals.filter((entry) => entry.verdictImpact === "watch").map((entry) => entry.id),
+            verdict: persistedReceipt.verdict,
+            receiptId: persistedReceipt.id,
+            blockedSignals: persistedReceipt.signals.filter((entry) => entry.verdictImpact === "blocked").map((entry) => entry.id),
+            watchSignals: persistedReceipt.signals.filter((entry) => entry.verdictImpact === "watch").map((entry) => entry.id),
         },
     });
-    return receipt;
+    return persistedReceipt;
 }
 function readHistory(paths, limit, issues) {
     if (!fs.existsSync(paths.historyDir))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.663",
+  "version": "0.1.0-alpha.664",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",