@ouro.bot/cli 0.1.0-alpha.690 → 0.1.0-alpha.692

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_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.692",
+      "changes": [
+        "Retry transient managed-sense runtime credential reads with bounded backoff so enabled senses recover from vault timeouts without a daemon restart.",
+        "Rotate NDJSON logs immediately after a single oversized final event and make doctor ignore launchd plists for paused or unscheduled habits while avoiding prune warnings for already-rotated compressed history."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.691",
+      "changes": [
+        "Bound context-loss Sentinel per-receipt detail files while preserving append-only history, so long-lived agents cannot accumulate unbounded duplicate recovery JSON in their bundles."
+      ]
+    },
     {
       "version": "0.1.0-alpha.690",
       "changes": [

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

@@ -47,6 +47,7 @@ const flight_recorder_1 = require("../arc/flight-recorder");
 const runtime_1 = require("../nerves/runtime");
 const context_loss_gauntlet_1 = require("./context-loss-gauntlet");
 const provider_visibility_1 = require("./provider-visibility");
+const CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT = 512;
 const REQUIRED_LANES = ["outward", "inner"];
 function logicalLocator(...parts) {
     return path.posix.join(...parts);
@@ -324,6 +325,43 @@ function readReceiptFile(filePath, label, issues) {
     }
     return parsed.value;
 }
+function receiptIdFromFileName(fileName) {
+    return fileName.endsWith(".json") ? fileName.slice(0, -".json".length) : null;
+}
+function receiptOrderFromDetailFile(filePath, fileName) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (isReceipt(parsed))
+            return orderFromReceipt(parsed);
+    }
+    catch {
+        // Malformed legacy detail files should not block retention cleanup.
+    }
+    const stat = fs.statSync(filePath);
+    return {
+        generatedAt: new Date(stat.mtimeMs).toISOString(),
+        id: receiptIdFromFileName(fileName),
+    };
+}
+function pruneReceiptDetailFiles(paths, protectedReceiptIds) {
+    const fileNames = fs.readdirSync(paths.receiptsDir)
+        .filter((entry) => receiptIdFromFileName(entry) !== null);
+    if (fileNames.length <= CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT)
+        return;
+    const candidates = fileNames
+        .map((fileName) => ({
+        fileName,
+        filePath: path.join(paths.receiptsDir, fileName),
+        receiptId: receiptIdFromFileName(fileName),
+        order: receiptOrderFromDetailFile(path.join(paths.receiptsDir, fileName), fileName),
+    }))
+        .filter((entry) => !protectedReceiptIds.has(entry.receiptId))
+        .sort((left, right) => compareOrder(left.order, right.order));
+    const removalCount = fileNames.length - CONTEXT_LOSS_SENTINEL_RECEIPT_FILE_LIMIT;
+    for (const entry of candidates.slice(0, removalCount)) {
+        fs.rmSync(entry.filePath, { force: true });
+    }
+}
 function isNonEmptyText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -806,19 +844,24 @@ async function persistReceipt(agentRoot, receipt, lockTimeoutMs) {
         const coalesced = coalescedDaemonHealthReceipt(agentRoot, existingLatest, existingReady, receipt, watermark);
         if (coalesced)
             return coalesced;
-        atomicWriteJson(path.join(paths.receiptsDir, `${receipt.id}.json`), receipt);
+        const receiptPath = path.join(paths.receiptsDir, `${receipt.id}.json`);
+        atomicWriteJson(receiptPath, receipt);
+        setReceiptFileMtime(receiptPath, receipt);
         appendHistory(paths, receipt);
+        let latestAfterWrite = existingLatest ?? receipt;
         if (shouldReplaceLatestReceipt(existingLatest, receipt, latestOrder)) {
             atomicWriteJson(paths.latest, receipt);
             updateWatermarkOrder(watermark, "latest", receipt);
             writeWatermark(agentRoot, watermark);
             setReceiptFileMtime(paths.latest, receipt);
+            latestAfterWrite = receipt;
             recordBlockedReceiptEvent(agentRoot, receipt);
             recordRecoveredReceiptEvent(agentRoot, receipt);
         }
         else if (existingLatest && nextReady === receipt) {
             const updatedLatest = syncLatestReadyState(existingLatest, nextReady);
             atomicWriteJson(paths.latest, updatedLatest);
+            latestAfterWrite = updatedLatest;
         }
         if (receipt.verdict === "ready" && nextReady === receipt) {
             atomicWriteJson(paths.latestReady, receipt);
@@ -826,6 +869,10 @@ async function persistReceipt(agentRoot, receipt, lockTimeoutMs) {
             writeWatermark(agentRoot, watermark);
             setReceiptFileMtime(paths.latestReady, receipt);
         }
+        const protectedReceiptIds = new Set([receipt.id, latestAfterWrite.id]);
+        if (nextReady)
+            protectedReceiptIds.add(nextReady.id);
+        pruneReceiptDetailFiles(paths, protectedReceiptIds);
         return receipt;
     });
 }

package/dist/heart/daemon/cli-exec.js

@@ -7887,6 +7887,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             bundlesRoot: deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(),
             homedir: os.homedir(),
             envPath: process.env.PATH ?? "",
+            platform: process.platform,
         };
         const doctorResult = command.category
             ? await (0, doctor_1.runDoctorChecks)(doctorDeps, { category: command.category })

package/dist/heart/daemon/doctor.js

@@ -25,6 +25,9 @@ const bluebubbles_health_diagnostics_1 = require("./bluebubbles-health-diagnosti
 const ouro_path_installer_1 = require("../versioning/ouro-path-installer");
 const runtime_credentials_1 = require("../runtime-credentials");
 const machine_identity_1 = require("../machine-identity");
+const habit_parser_1 = require("../habits/habit-parser");
+const cadence_1 = require("./cadence");
+const nerves_1 = require("../../nerves");
 const DEFAULT_BLUEBUBBLES_REQUEST_TIMEOUT_MS = 30_000;
 // ── Category checkers ──
 function checkCliPath(deps) {
@@ -321,17 +324,73 @@ function checkHabits(deps) {
             continue;
         }
         checks.push({ label: `${agentDir} habits dir`, status: "pass", detail: habitsDir });
+        const activeScheduledHabits = [];
+        let unreadableHabits = 0;
+        for (const file of deps.readdirSync(habitsDir).filter((entry) => entry.endsWith(".md"))) {
+            const filePath = `${habitsDir}/${file}`;
+            try {
+                const habit = (0, habit_parser_1.parseHabitFile)(deps.readFileSync(filePath), filePath);
+                if (habit.status === "active" && habit.cadence && (0, cadence_1.parseCadenceToCron)(habit.cadence) !== null) {
+                    activeScheduledHabits.push(habit.name);
+                }
+            }
+            catch {
+                unreadableHabits += 1;
+            }
+        }
+        if (unreadableHabits > 0) {
+            checks.push({
+                label: `${agentDir} habit files`,
+                status: "warn",
+                detail: `${unreadableHabits} unreadable habit file(s)`,
+            });
+        }
+        if (activeScheduledHabits.length === 0) {
+            checks.push({
+                label: `${agentDir} launchd plists`,
+                status: "pass",
+                detail: "no active scheduled habits require launchd",
+            });
+            continue;
+        }
         // Check for launchd plists on macOS
+        const platform = deps.platform;
+        if (platform !== "darwin") {
+            checks.push({
+                label: `${agentDir} launchd plists`,
+                status: "pass",
+                detail: `launchd not applicable on ${platform}; scheduled habits use the platform cron manager`,
+            });
+            continue;
+        }
         const launchAgentsDir = `${deps.homedir}/Library/LaunchAgents`;
         if (deps.existsSync(launchAgentsDir)) {
-            const plists = deps.readdirSync(launchAgentsDir).filter((f) => f.startsWith(`bot.ouro.${agentName}.`) && f.endsWith(".plist"));
-            if (plists.length > 0) {
-                checks.push({ label: `${agentDir} launchd plists`, status: "pass", detail: `${plists.length} plist(s)` });
+            const plists = new Set(deps.readdirSync(launchAgentsDir));
+            const missing = activeScheduledHabits
+                .map((habitName) => `bot.ouro.${agentName}.${habitName}.plist`)
+                .filter((plistName) => !plists.has(plistName));
+            if (missing.length === 0) {
+                checks.push({
+                    label: `${agentDir} launchd plists`,
+                    status: "pass",
+                    detail: `${activeScheduledHabits.length} active scheduled habit(s) registered`,
+                });
             }
             else {
-                checks.push({ label: `${agentDir} launchd plists`, status: "fail", detail: "no matching plists in LaunchAgents" });
+                checks.push({
+                    label: `${agentDir} launchd plists`,
+                    status: "fail",
+                    detail: `missing ${missing.join(", ")}`,
+                });
             }
         }
+        else {
+            checks.push({
+                label: `${agentDir} launchd plists`,
+                status: "fail",
+                detail: `${launchAgentsDir} not found for ${activeScheduledHabits.length} active scheduled habit(s)`,
+            });
+        }
     }
     if (checks.length === 0) {
         checks.push({ label: "habits", status: "warn", detail: "no agents found" });
@@ -630,14 +689,29 @@ function checkFriends(deps) {
 }
 function checkDisk(deps) {
     const checks = [];
+    const isActiveLogStream = (name) => {
+        if (name.endsWith(".ndjson"))
+            return !/\.\d+\.ndjson$/.test(name);
+        if (name.endsWith(".log"))
+            return !/\.\d+\.log$/.test(name);
+        return false;
+    };
     const addLogSizeCheck = (labelPrefix, logsDir) => {
         let totalSize = 0;
+        let activeSize = 0;
+        const oversizedActive = [];
         try {
             const files = deps.readdirSync(logsDir);
             for (const file of files) {
                 try {
                     const stat = deps.statSync(`${logsDir}/${file}`);
                     totalSize += stat.size;
+                    if (isActiveLogStream(file)) {
+                        activeSize += stat.size;
+                        if (stat.size >= nerves_1.DEFAULT_MAX_LOG_SIZE_BYTES) {
+                            oversizedActive.push(file);
+                        }
+                    }
                 }
                 catch {
                     // skip unreadable files
@@ -648,14 +722,19 @@ function checkDisk(deps) {
             // readdirSync failure handled below
         }
         const sizeMB = totalSize / (1024 * 1024);
-        if (sizeMB > 500) {
-            checks.push({ label: `${labelPrefix} daemon log size`, status: "fail", detail: `${sizeMB.toFixed(1)}MB — exceeds 500MB limit` });
+        const activeSizeMB = activeSize / (1024 * 1024);
+        if (activeSizeMB > 500) {
+            checks.push({ label: `${labelPrefix} daemon log size`, status: "fail", detail: `${activeSizeMB.toFixed(1)}MB active / ${sizeMB.toFixed(1)}MB total — active logs exceed 500MB limit` });
         }
-        else if (sizeMB > 100) {
-            checks.push({ label: `${labelPrefix} daemon log size`, status: "warn", detail: `${sizeMB.toFixed(1)}MB — consider pruning with \`ouro logs prune\`` });
+        else if (oversizedActive.length > 0) {
+            checks.push({
+                label: `${labelPrefix} daemon log size`,
+                status: "warn",
+                detail: `${activeSizeMB.toFixed(1)}MB active / ${sizeMB.toFixed(1)}MB total; active stream(s) over ${Math.round(nerves_1.DEFAULT_MAX_LOG_SIZE_BYTES / (1024 * 1024))}MB: ${oversizedActive.join(", ")} — run \`ouro logs prune\``,
+            });
         }
         else {
-            checks.push({ label: `${labelPrefix} daemon log size`, status: "pass", detail: `${sizeMB.toFixed(1)}MB` });
+            checks.push({ label: `${labelPrefix} daemon log size`, status: "pass", detail: `${activeSizeMB.toFixed(1)}MB active / ${sizeMB.toFixed(1)}MB total` });
         }
     };
     const agents = discoverAgents(deps);

package/dist/heart/daemon/sense-manager.js

@@ -49,6 +49,7 @@ const DEFAULT_TEAMS_PORT = 3978;
 const DEFAULT_BLUEBUBBLES_PORT = 18790;
 const DEFAULT_BLUEBUBBLES_WEBHOOK_PATH = "/bluebubbles-webhook";
 const BLUEBUBBLES_RUNTIME_FRESHNESS_WINDOW_MS = 90_000;
+const SENSE_CONFIG_RETRY_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 30_000, 60_000];
 function defaultSenses() {
     return {
         cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
@@ -519,6 +520,8 @@ class DaemonSenseManager {
     processManager;
     contexts;
     pendingConfigRefreshes = new Set();
+    configRefreshRetryTimers = new Map();
+    configRefreshRetryAttempts = new Map();
     bundlesRoot;
     constructor(options) {
         const bundlesRoot = options.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
@@ -580,13 +583,55 @@ class DaemonSenseManager {
             },
         });
     }
-    scheduleSenseConfigRefresh(name, parsed) {
-        if (this.pendingConfigRefreshes.has(name))
+    scheduleSenseConfigRefresh(name, parsed, delayMs = 0) {
+        if (this.pendingConfigRefreshes.has(name) || this.configRefreshRetryTimers.has(name))
             return;
+        if (delayMs > 0) {
+            const timer = setTimeout(() => {
+                this.configRefreshRetryTimers.delete(name);
+                this.pendingConfigRefreshes.add(name);
+                void this.refreshSenseConfigAndRetry(name, parsed);
+            }, delayMs);
+            this.configRefreshRetryTimers.set(name, timer);
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "channels",
+                event: "channel.daemon_sense_config_retry_scheduled",
+                message: "scheduled managed sense config retry",
+                meta: {
+                    agent: parsed.agent,
+                    sense: parsed.sense,
+                    managedName: name,
+                    delayMs,
+                    attempt: this.configRefreshRetryAttempts.get(name),
+                },
+            });
+            return;
+        }
         this.pendingConfigRefreshes.add(name);
         void this.refreshSenseConfigAndRetry(name, parsed);
     }
+    nextConfigRetryDelayMs(name) {
+        const attempt = (this.configRefreshRetryAttempts.get(name) ?? 0) + 1;
+        this.configRefreshRetryAttempts.set(name, attempt);
+        return SENSE_CONFIG_RETRY_DELAYS_MS[Math.min(attempt - 1, SENSE_CONFIG_RETRY_DELAYS_MS.length - 1)];
+    }
+    clearConfigRetryState(name) {
+        clearTimeout(this.configRefreshRetryTimers.get(name));
+        this.configRefreshRetryTimers.delete(name);
+        this.configRefreshRetryAttempts.delete(name);
+    }
+    shouldRetryConfigRefresh(sense, runtimeConfig, machineRuntimeConfig) {
+        if (!runtimeConfig.ok && runtimeConfig.reason === "unavailable")
+            return true;
+        if ((sense === "bluebubbles" || sense === "voice" || sense === "a2a") &&
+            !machineRuntimeConfig.ok &&
+            machineRuntimeConfig.reason === "unavailable")
+            return true;
+        return false;
+    }
     async refreshSenseConfigAndRetry(name, parsed) {
+        let retryAfterMs = null;
         try {
             const refreshed = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(parsed.agent, { preserveCachedOnFailure: true });
             const machineRefreshed = parsed.sense === "bluebubbles" || parsed.sense === "voice" || parsed.sense === "a2a"
@@ -597,8 +642,16 @@ class DaemonSenseManager {
             if (!context)
                 return;
             context.facts = senseFactsFromRuntimeConfig(parsed.agent, context.senses, refreshed, machineRefreshed);
-            if (!context.facts[parsed.sense].configured)
+            if (!context.facts[parsed.sense].configured) {
+                if (this.shouldRetryConfigRefresh(parsed.sense, refreshed, machineRefreshed)) {
+                    retryAfterMs = this.nextConfigRetryDelayMs(name);
+                }
+                else {
+                    this.clearConfigRetryState(name);
+                }
                 return;
+            }
+            this.clearConfigRetryState(name);
             setTimeout(() => {
                 void this.processManager.startAgent?.(name).catch((error) => {
                     (0, runtime_1.emitNervesEvent)({
@@ -624,6 +677,9 @@ class DaemonSenseManager {
         }
         finally {
             this.pendingConfigRefreshes.delete(name);
+            if (retryAfterMs !== null) {
+                this.scheduleSenseConfigRefresh(name, parsed, retryAfterMs);
+            }
         }
     }
     async refreshEnabledSenseConfigs() {
@@ -676,6 +732,11 @@ class DaemonSenseManager {
         });
     }
     async stopAll() {
+        for (const timer of this.configRefreshRetryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.configRefreshRetryTimers.clear();
+        this.configRefreshRetryAttempts.clear();
         await this.processManager.stopAll();
     }
     /* v8 ignore start -- pid collection for orphan cleanup pidfile @preserve */

package/dist/nerves/index.js

@@ -303,7 +303,9 @@ function createNdjsonFileSink(filePath, optionsOrMaxSize) {
             return;
         flushing = true;
         const line = queue.shift();
-        if (bytesSinceCheck >= rotationCheckInterval) {
+        const checkBeforeAppend = bytesSinceCheck >= rotationCheckInterval;
+        const checkAfterAppend = checkBeforeAppend || line.length >= rotationCheckInterval;
+        if (checkBeforeAppend) {
             bytesSinceCheck = 0;
             try {
                 rotateIfNeeded(filePath, options);
@@ -313,6 +315,14 @@ function createNdjsonFileSink(filePath, optionsOrMaxSize) {
             }
         }
         (0, fs_1.appendFile)(filePath, line, "utf8", () => {
+            if (checkAfterAppend) {
+                try {
+                    rotateIfNeeded(filePath, options);
+                }
+                catch {
+                    // Rotation errors are surfaced via nerves events; never block writes.
+                }
+            }
             flushing = false;
             flush();
         });

package/package.json

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