@ouro.bot/cli 0.1.0-alpha.691 → 0.1.0-alpha.693

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.693",
+      "changes": [
+        "Load vault-backed provider credentials before manual context-loss Sentinel refreshes so a fresh CLI process cannot report false not-loaded provider warnings.",
+        "Have doctor lifecycle checks read the machine-local daemon log alongside bundle-local logs so stale historical bundle logs cannot mask live daemon activity."
+      ]
+    },
+    {
+      "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": [

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

@@ -7647,6 +7647,9 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             throw new Error("work sentinel requires --agent <name>");
         const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         const agentRoot = deps.agentBundleRoot ?? path.join(bundlesRoot, `${command.agent}.ouro`);
+        if (command.kind === "work.sentinel.refresh") {
+            await (0, provider_credentials_1.refreshProviderCredentialPool)(command.agent, { preserveCachedOnFailure: true });
+        }
         const sentinel = command.kind === "work.sentinel.refresh"
             ? await refreshContextLossSentinel(command.agent, agentRoot, { trigger: "manual_cli", homeDir: deps.homeDir })
             : readContextLossSentinelView(agentRoot, { limit: 20 });
@@ -7885,8 +7888,10 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
             fetchImpl: deps.fetchImpl ?? fetch,
             socketPath: deps.socketPath,
             bundlesRoot: deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(),
+            daemonLogsDir: path.join((0, ouro_version_manager_1.getOuroCliHome)(deps.homeDir), "daemon", "logs"),
             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);
@@ -704,83 +783,106 @@ function computeSummary(categories) {
  * to answer the operator's question after the daemon has gone silent: "did
  * it crash? when did it last do anything? did it just upgrade?"
  *
- * Reads daemon.ndjson from the first available agent bundle (one daemon
- * serves all agents, so any agent's bundle has the shared log).
+ * Reads the machine-local daemon.ndjson when available, plus any
+ * bundle-local copies left by older runtimes. The newest parseable event
+ * is the liveness signal; stale bundle logs cannot mask a live daemon.
  */
 function checkLifecycle(deps) {
     const checks = [];
     const HOUR_MS = 60 * 60 * 1000;
     const STALE_THRESHOLD_MS = 5 * 60 * 1000;
-    const cutoff = Date.now() - HOUR_MS;
+    const now = Date.now();
+    const cutoff = now - HOUR_MS;
+    const logPaths = [];
+    const seenLogPaths = new Set();
+    const addLogPath = (candidate) => {
+        if (seenLogPaths.has(candidate) || !deps.existsSync(candidate))
+            return;
+        seenLogPaths.add(candidate);
+        logPaths.push(candidate);
+    };
+    if (deps.daemonLogsDir) {
+        addLogPath(`${deps.daemonLogsDir}/daemon.ndjson`);
+    }
     const agents = discoverAgents(deps);
-    let logPath = null;
     for (const agentDir of agents) {
-        const candidate = `${deps.bundlesRoot}/${agentDir}/state/daemon/logs/daemon.ndjson`;
-        if (deps.existsSync(candidate)) {
-            logPath = candidate;
-            break;
-        }
+        addLogPath(`${deps.bundlesRoot}/${agentDir}/state/daemon/logs/daemon.ndjson`);
     }
-    if (!logPath) {
-        checks.push({ label: "daemon log readable", status: "warn", detail: "no daemon.ndjson found in any agent bundle" });
+    if (logPaths.length === 0) {
+        checks.push({ label: "daemon log readable", status: "warn", detail: "no daemon.ndjson found in daemon or agent bundle logs" });
         return { name: "Lifecycle", checks };
     }
     let lastTs = null;
     let lastEvent = null;
+    let lastEventTimeMs = Number.NEGATIVE_INFINITY;
     let startCount = 0;
     let installCount = 0;
     let installVersions = [];
     let processErrors = [];
     let lastEntryAgeMs = Number.POSITIVE_INFINITY;
-    try {
-        // Read the whole log via deps.readFileSync, then take the tail. For a
-        // chatty daemon this can be a few MB; we only inspect the last 5000
-        // lines which is enough for the last hour of activity. If the file is
-        // small (typical case), reading it all is cheap.
-        const raw = deps.readFileSync(logPath);
-        const allLines = raw.split("\n").filter((l) => l.trim());
-        const usable = allLines.length > 5000 ? allLines.slice(-5000) : allLines;
-        for (const line of usable) {
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const ts = typeof parsed.ts === "string" ? parsed.ts : null;
-            const event = typeof parsed.event === "string" ? parsed.event : null;
-            if (!ts || !event)
-                continue;
-            const tsMs = Date.parse(ts);
-            if (Number.isNaN(tsMs))
-                continue;
-            lastTs = ts;
-            lastEvent = event;
-            lastEntryAgeMs = Math.min(lastEntryAgeMs, Date.now() - tsMs);
-            if (tsMs < cutoff)
-                continue;
-            if (event === "daemon.daemon_started")
-                startCount++;
-            if (event === "daemon.cli_version_install_end") {
-                installCount++;
-                const meta = parsed.meta;
-                const ver = typeof meta?.version === "string" ? meta.version : null;
-                if (ver)
-                    installVersions.push(ver);
-            }
-            if (event === "daemon.agent_process_error") {
-                const meta = parsed.meta;
-                const reason = typeof meta?.reason === "string" ? meta.reason : "unknown";
-                const agent = typeof meta?.agent === "string" ? meta.agent : "unknown";
-                processErrors.push(`${agent}: ${reason}`);
+    let readCount = 0;
+    const readErrors = [];
+    for (const logPath of logPaths) {
+        try {
+            // Read the whole log via deps.readFileSync, then take the tail. For a
+            // chatty daemon this can be a few MB; we only inspect the last 5000
+            // lines which is enough for the last hour of activity. If the file is
+            // small (typical case), reading it all is cheap.
+            const raw = deps.readFileSync(logPath);
+            readCount++;
+            const allLines = raw.split("\n").filter((l) => l.trim());
+            const usable = allLines.length > 5000 ? allLines.slice(-5000) : allLines;
+            for (const line of usable) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const ts = typeof parsed.ts === "string" ? parsed.ts : null;
+                const event = typeof parsed.event === "string" ? parsed.event : null;
+                if (!ts || !event)
+                    continue;
+                const tsMs = Date.parse(ts);
+                if (Number.isNaN(tsMs))
+                    continue;
+                if (tsMs > lastEventTimeMs) {
+                    lastEventTimeMs = tsMs;
+                    lastTs = ts;
+                    lastEvent = event;
+                    lastEntryAgeMs = Math.max(0, now - tsMs);
+                }
+                if (tsMs < cutoff)
+                    continue;
+                if (event === "daemon.daemon_started")
+                    startCount++;
+                if (event === "daemon.cli_version_install_end") {
+                    installCount++;
+                    const meta = parsed.meta;
+                    const ver = typeof meta?.version === "string" ? meta.version : null;
+                    if (ver)
+                        installVersions.push(ver);
+                }
+                if (event === "daemon.agent_process_error") {
+                    const meta = parsed.meta;
+                    const reason = typeof meta?.reason === "string" ? meta.reason : "unknown";
+                    const agent = typeof meta?.agent === "string" ? meta.agent : "unknown";
+                    processErrors.push(`${agent}: ${reason}`);
+                }
             }
         }
+        catch (error) {
+            readErrors.push(`${logPath}: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from deps.readFileSync (always Error) @preserve */ String(error)}`);
+        }
     }
-    catch (error) {
-        checks.push({ label: "daemon log readable", status: "fail", detail: `read failed: ${error instanceof Error ? error.message : /* v8 ignore next -- non-Error throw is unreachable from deps.readFileSync (always Error) @preserve */ String(error)}` });
+    if (readCount === 0) {
+        checks.push({ label: "daemon log readable", status: "fail", detail: `read failed: ${readErrors.join("; ")}` });
         return { name: "Lifecycle", checks };
     }
+    if (readErrors.length > 0) {
+        checks.push({ label: "daemon log readable", status: "warn", detail: `some daemon logs were unreadable: ${readErrors.join("; ")}` });
+    }
     if (lastTs === null) {
         checks.push({ label: "recent daemon activity", status: "warn", detail: "no parseable events in tail of daemon.ndjson" });
     }

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.691",
+  "version": "0.1.0-alpha.693",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",