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

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.665",
+      "changes": [
+        "Ignore Sentinel-owned daemon-health git dirt when computing the Sentinel bundle signal, preventing a self-sustaining health-receipt loop while keeping real bundle dirt visible."
+      ]
+    },
+    {
+      "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")) };
@@ -385,7 +482,7 @@ function healthSignals(results) {
 }
 function defaultGitStatus(agentRoot) {
     try {
-        const porcelain = (0, child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+        const porcelain = (0, child_process_1.execFileSync)("git", ["status", "--porcelain=v1", "-uall"], {
             cwd: agentRoot,
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "pipe"],
@@ -397,7 +494,50 @@ function defaultGitStatus(agentRoot) {
         return { ok: false, error: String(error) };
     }
 }
-function bundleSignal(status) {
+function gitStatusEntries(porcelain) {
+    return porcelain.split(/\r?\n/).filter((line) => line.trim().length > 0);
+}
+function normalizeGitStatusPath(entryPath) {
+    return entryPath.trim().replace(/^"|"$/g, "");
+}
+function gitStatusPaths(entry) {
+    const rawPath = entry.slice(3).trim();
+    const paths = [];
+    let start = 0;
+    let inQuote = false;
+    let escaped = false;
+    for (let index = 0; index < rawPath.length; index += 1) {
+        const char = rawPath[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (inQuote && char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === "\"") {
+            inQuote = !inQuote;
+            continue;
+        }
+        if (!inQuote && rawPath.startsWith(" -> ", index)) {
+            paths.push(rawPath.slice(start, index));
+            start = index + 4;
+            index += 3;
+        }
+    }
+    paths.push(rawPath.slice(start));
+    return paths.map(normalizeGitStatusPath);
+}
+function isSentinelGitStatusEntry(entry) {
+    const sentinelRoot = relativeSentinelRoot();
+    return gitStatusPaths(entry).every((entryPath) => {
+        const normalizedPath = entryPath.replace(/\/$/, "");
+        return normalizedPath === sentinelRoot || normalizedPath.startsWith(`${sentinelRoot}/`);
+    });
+}
+function bundleSignal(status, options = {}) {
+    const gitStatusCommand = "git status --porcelain=v1 -uall";
     if (!status.ok) {
         return {
             id: "bundle:git",
@@ -406,11 +546,12 @@ function bundleSignal(status) {
             severity: "warn",
             verdictImpact: "watch",
             summary: `bundle git status unavailable: ${status.error}`,
-            source: { kind: "git", locator: "git status --porcelain" },
-            repair: repair("agent-runnable", "bundle-cleanup", "Inspect bundle git state before assuming the local state is clean.", "git status --porcelain"),
+            source: { kind: "git", locator: gitStatusCommand },
+            repair: repair("agent-runnable", "bundle-cleanup", "Inspect bundle git state before assuming the local state is clean.", gitStatusCommand),
         };
     }
-    const dirtyEntries = status.porcelain.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const dirtyEntries = gitStatusEntries(status.porcelain)
+        .filter((entry) => !(options.ignoreSentinelDirtyEntries && isSentinelGitStatusEntry(entry)));
     if (dirtyEntries.length > 0) {
         return {
             id: "bundle:git",
@@ -419,8 +560,8 @@ function bundleSignal(status) {
             severity: "warn",
             verdictImpact: "watch",
             summary: `bundle has ${dirtyEntries.length} uncommitted git status entr${dirtyEntries.length === 1 ? "y" : "ies"}`,
-            source: { kind: "git", locator: "git status --porcelain" },
-            repair: repair("agent-runnable", "bundle-cleanup", "Resolve or intentionally preserve local bundle changes before handoff.", "git status --porcelain"),
+            source: { kind: "git", locator: gitStatusCommand },
+            repair: repair("agent-runnable", "bundle-cleanup", "Resolve or intentionally preserve local bundle changes before handoff.", gitStatusCommand),
             meta: { dirtyEntries },
         };
     }
@@ -431,7 +572,7 @@ function bundleSignal(status) {
         severity: "info",
         verdictImpact: "none",
         summary: "bundle git status clean",
-        source: { kind: "git", locator: "git status --porcelain" },
+        source: { kind: "git", locator: gitStatusCommand },
     };
 }
 function sentinelVerdict(signals) {
@@ -536,7 +677,9 @@ function makeReceipt(agentName, agentRoot, options, generatedAt) {
         gauntletSignal(report),
         ...deriveContextLossSentinelProviderSignals(providerVisibility),
         ...healthSignals(options.daemonHealthResults ?? []),
-        bundleSignal((options.gitStatus ?? (() => defaultGitStatus(agentRoot)))()),
+        bundleSignal((options.gitStatus ?? (() => defaultGitStatus(agentRoot)))(), {
+            ignoreSentinelDirtyEntries: options.trigger === "daemon_health",
+        }),
     ];
     const verdict = sentinelVerdict(signals);
     const latestReady = readLatestReady(agentRoot);
@@ -619,26 +762,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 +802,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 +810,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.665",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",