@ouro.bot/cli 0.1.0-alpha.35 → 0.1.0-alpha.350

package/dist/heart/daemon/logs-prune.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneDaemonLogs = pruneDaemonLogs;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const nerves_1 = require("../../nerves");
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+function pruneDaemonLogs(options = {}) {
+    /* v8 ignore next -- defensive: tests always pass logsDir to avoid prod paths @preserve */
+    const logsDir = options.logsDir ?? (0, identity_1.getAgentDaemonLogsDir)(options.agentName);
+    const maxSizeBytes = options.maxSizeBytes ?? nerves_1.DEFAULT_MAX_LOG_SIZE_BYTES;
+    const maxGenerations = options.maxGenerations ?? nerves_1.DEFAULT_MAX_GENERATIONS;
+    const traceId = (0, crypto_1.randomUUID)();
+    (0, runtime_1.emitNervesEvent)({
+        component: "nerves",
+        event: "nerves.logs_prune_start",
+        trace_id: traceId,
+        message: "pruning daemon logs",
+        meta: { logsDir, maxSizeBytes, maxGenerations },
+    });
+    let completed = false;
+    try {
+        if (!(0, fs_1.existsSync)(logsDir)) {
+            completed = true;
+            (0, runtime_1.emitNervesEvent)({
+                component: "nerves",
+                event: "nerves.logs_prune_end",
+                trace_id: traceId,
+                message: "daemon logs dir does not exist",
+                meta: { logsDir, filesCompacted: 0, bytesFreed: 0 },
+            });
+            return { filesCompacted: 0, bytesFreed: 0 };
+        }
+        let filesCompacted = 0;
+        let bytesFreed = 0;
+        // Enumerate and rotate each active .ndjson stream. We explicitly skip
+        // .gz and other files — only the active stream can be a rotation
+        // candidate. Legacy .N.ndjson uncompressed files are handled inside
+        // rotateIfNeeded's generation-shift step, so we skip them here to
+        // avoid double-rotating.
+        for (const name of (0, fs_1.readdirSync)(logsDir)) {
+            if (!name.endsWith(".ndjson"))
+                continue;
+            // Skip legacy generation files like daemon.1.ndjson; rotateIfNeeded
+            // will migrate them on the next rotation of their parent stream.
+            if (/\.\d+\.ndjson$/.test(name))
+                continue;
+            const filePath = (0, path_1.join)(logsDir, name);
+            let sizeBefore;
+            try {
+                sizeBefore = (0, fs_1.statSync)(filePath).size;
+                /* v8 ignore start -- defensive: file disappears between readdir and stat @preserve */
+            }
+            catch {
+                continue;
+            }
+            /* v8 ignore stop */
+            if (sizeBefore < maxSizeBytes)
+                continue;
+            // rotateIfNeeded returns true because we pre-checked sizeBefore >=
+            // maxSizeBytes above. The false branch of `if (rotated)` is defensive
+            // and unreachable under normal flow; we skip it from coverage so a
+            // future refactor that weakens the pre-check still reports correct
+            // counts without needing a contrived test.
+            const rotated = (0, nerves_1.rotateIfNeeded)(filePath, {
+                maxSizeBytes,
+                maxGenerations,
+                compress: true,
+            });
+            /* v8 ignore next 3 -- defensive: pre-check guarantees rotated=true @preserve */
+            if (!rotated) {
+                continue;
+            }
+            filesCompacted += 1;
+            bytesFreed += sizeBefore;
+        }
+        completed = true;
+        (0, runtime_1.emitNervesEvent)({
+            component: "nerves",
+            event: "nerves.logs_prune_end",
+            trace_id: traceId,
+            message: "daemon logs pruned",
+            meta: { logsDir, filesCompacted, bytesFreed },
+        });
+        return { filesCompacted, bytesFreed };
+    }
+    catch (err) {
+        /* v8 ignore next -- defensive: completed=true only reached after try returns @preserve */
+        if (!completed) {
+            /* v8 ignore next -- defensive: rotation always throws real Errors @preserve */
+            const reason = err instanceof Error ? err.message : String(err);
+            (0, runtime_1.emitNervesEvent)({
+                component: "nerves",
+                event: "nerves.logs_prune_error",
+                trace_id: traceId,
+                level: "error",
+                message: "daemon logs prune failed",
+                meta: { logsDir, error: reason },
+            });
+        }
+        throw err;
+    }
+}

package/dist/heart/daemon/message-router.js

@@ -35,9 +35,9 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileMessageRouter = void 0;
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
 function messageId(nowIso) {
     return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
 }
@@ -45,7 +45,7 @@ class FileMessageRouter {
     baseDir;
     now;
     constructor(options = {}) {
-        this.baseDir = options.baseDir ?? path.join(os.homedir(), ".agentstate", "messages");
+        this.baseDir = options.baseDir ?? (0, identity_1.getAgentMessagesRoot)();
         this.now = options.now ?? (() => new Date().toISOString());
         fs.mkdirSync(this.baseDir, { recursive: true });
     }
@@ -77,12 +77,21 @@ class FileMessageRouter {
         if (!fs.existsSync(inboxPath))
             return [];
         const raw = fs.readFileSync(inboxPath, "utf-8");
-        fs.writeFileSync(inboxPath, "", "utf-8");
-        const messages = raw
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .map((line) => JSON.parse(line));
+        const messages = [];
+        const unparsed = [];
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                messages.push(JSON.parse(trimmed));
+            }
+            catch {
+                unparsed.push(trimmed);
+            }
+        }
+        // Only clear inbox after parsing; preserve lines that failed to parse.
+        fs.writeFileSync(inboxPath, unparsed.length > 0 ? unparsed.map((l) => `${l}\n`).join("") : "", "utf-8");
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.message_polled",

package/dist/heart/daemon/os-cron-deps.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRealOsCronDeps = createRealOsCronDeps;
+exports.createRealCrontabDeps = createRealCrontabDeps;
+exports.resolveOuroBinaryPath = resolveOuroBinaryPath;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function createRealOsCronDeps() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.os_cron_deps_created",
+        message: "created real OS cron deps",
+        meta: { platform: process.platform },
+    });
+    return {
+        exec: (cmd) => {
+            try {
+                (0, child_process_1.execSync)(cmd, { stdio: "ignore" });
+            }
+            catch {
+                /* best effort */
+            }
+        },
+        writeFile: (p, c) => fs.writeFileSync(p, c, "utf-8"),
+        removeFile: (p) => {
+            try {
+                fs.unlinkSync(p);
+            }
+            catch {
+                /* best effort — file may already be gone */
+            }
+        },
+        existsFile: (p) => fs.existsSync(p),
+        listDir: (dir) => {
+            try {
+                return fs.readdirSync(dir);
+            }
+            catch {
+                return [];
+            }
+        },
+        mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
+        homeDir: os.homedir(),
+    };
+}
+function createRealCrontabDeps() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.crontab_deps_created",
+        message: "created real crontab deps",
+        meta: {},
+    });
+    /* v8 ignore start -- crontab exec closures: calling these in tests would modify the real system crontab @preserve */
+    return {
+        execOutput: (cmd) => (0, child_process_1.execSync)(cmd, { encoding: "utf-8" }),
+        execWrite: (cmd, stdin) => {
+            (0, child_process_1.execSync)(cmd, { input: stdin, stdio: ["pipe", "ignore", "ignore"] });
+        },
+    };
+    /* v8 ignore stop */
+}
+/* v8 ignore start -- ouro path resolution: probes process.argv, filesystem layout, and PATH; branches depend on install method and runtime environment @preserve */
+function resolveOuroBinaryPath() {
+    // Try to resolve from process.argv[1] — the script being run
+    const scriptPath = process.argv[1];
+    if (scriptPath) {
+        // If running via node dist/heart/daemon/daemon-entry.js, resolve the ouro wrapper
+        // The ouro binary is typically at the package root's bin
+        const distDir = path.resolve(path.dirname(scriptPath));
+        const packageBin = path.resolve(distDir, "..", "..", "..", "node_modules", ".bin", "ouro");
+        if (fs.existsSync(packageBin)) {
+            return packageBin;
+        }
+        // Try the repo-local scripts/ouro.sh
+        const repoOuro = path.resolve(distDir, "..", "..", "..", "scripts", "ouro.sh");
+        if (fs.existsSync(repoOuro)) {
+            return repoOuro;
+        }
+    }
+    // Try which ouro
+    try {
+        const result = (0, child_process_1.execSync)("which ouro", { encoding: "utf-8" }).trim();
+        if (result.length > 0)
+            return result;
+    }
+    catch {
+        /* not on PATH */
+    }
+    // Fallback: use "ouro" and rely on PATH
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_fallback",
+        message: "could not resolve full ouro binary path, falling back to 'ouro'",
+        meta: {},
+    });
+    return "ouro";
+}
+/* v8 ignore stop */

package/dist/heart/daemon/ouro-bot-entry.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const runtime_1 = require("../../nerves/runtime");
 const runtime_logging_1 = require("./runtime-logging");
-const ouro_bot_wrapper_1 = require("./ouro-bot-wrapper");
+const ouro_bot_wrapper_1 = require("../versioning/ouro-bot-wrapper");
 (0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro-bot");
 (0, runtime_1.emitNervesEvent)({
     component: "daemon",

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

@@ -51,15 +51,70 @@ class DaemonProcessManager {
     now;
     setTimeoutFn;
     clearTimeoutFn;
+    cooldownRecoveryMs;
+    maxCooldownRetries;
+    existsSyncFn;
+    configCheckFn;
+    statusWriterFn;
+    onSnapshotChangeFn;
+    /**
+     * Notify the snapshot-change observer (if registered). Swallows any
+     * errors from the observer so process lifecycle code never fails
+     * because the observer threw.
+     */
+    notifySnapshotChange(snapshot) {
+        if (!this.onSnapshotChangeFn)
+            return;
+        try {
+            this.onSnapshotChangeFn(snapshot);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.snapshot_change_observer_error",
+                message: "snapshot-change observer threw",
+                meta: {
+                    agent: snapshot.name,
+                    error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error),
+                },
+            });
+        }
+    }
+    writeStatus(agent, text) {
+        try {
+            this.statusWriterFn(text);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.status_writer_error",
+                message: "daemon status writer threw",
+                meta: {
+                    agent,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     constructor(options) {
         this.maxRestartsPerHour = options.maxRestartsPerHour ?? 10;
         this.stabilityThresholdMs = options.stabilityThresholdMs ?? 60_000;
         this.initialBackoffMs = options.initialBackoffMs ?? 1_000;
         this.maxBackoffMs = options.maxBackoffMs ?? 60_000;
+        this.cooldownRecoveryMs = options.cooldownRecoveryMs ?? 5 * 60 * 1_000;
+        this.maxCooldownRetries = options.maxCooldownRetries ?? 3;
         this.spawnFn = options.spawn ?? ((command, args, spawnOptions) => (0, child_process_1.spawn)(command, args, spawnOptions));
         this.now = options.now ?? (() => Date.now());
         this.setTimeoutFn = options.setTimeoutFn ?? ((cb, delay) => setTimeout(cb, delay));
         this.clearTimeoutFn = options.clearTimeoutFn ?? ((timer) => clearTimeout(timer));
+        this.existsSyncFn = options.existsSync ?? null;
+        this.configCheckFn = options.configCheck ?? null;
+        this.statusWriterFn = options.statusWriter ?? ((text) => {
+            process.stderr.write(text);
+        });
+        this.onSnapshotChangeFn = options.onSnapshotChange ?? null;
         for (const agent of options.agents) {
             this.agents.set(agent.name, {
                 config: agent,
@@ -67,6 +122,9 @@ class DaemonProcessManager {
                 restartTimer: null,
                 crashTimestamps: [],
                 stopRequested: false,
+                cooldownTimer: null,
+                cooldownRetryCount: 0,
+                fastCrashCount: 0,
                 snapshot: {
                     name: agent.name,
                     channel: agent.channel,
@@ -76,6 +134,10 @@ class DaemonProcessManager {
                     startedAt: null,
                     lastCrashAt: null,
                     backoffMs: this.initialBackoffMs,
+                    lastExitCode: null,
+                    lastSignal: null,
+                    errorReason: null,
+                    fixHint: null,
                 },
             });
         }
@@ -94,14 +156,62 @@ class DaemonProcessManager {
         this.clearRestartTimer(state);
         state.stopRequested = false;
         state.snapshot.status = "starting";
+        if (this.configCheckFn) {
+            const result = await this.configCheckFn(agent);
+            if (!result.ok) {
+                state.snapshot.status = "crashed";
+                // Surface the error and fix to the snapshot so sibling agents can
+                // read it via the pulse. Without this, the diagnosis stayed
+                // trapped in the nerves event and stderr — visible to humans
+                // running `ouro status` or grepping logs, but invisible to
+                // peer agents trying to coordinate around the broken state.
+                state.snapshot.errorReason = result.error ?? "agent config validation failed";
+                state.snapshot.fixHint = result.fix ?? null;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_config_invalid",
+                    message: result.error ?? "agent config validation failed",
+                    meta: { agent, fix: result.fix ?? null },
+                });
+                this.writeStatus(agent, `[daemon] ${agent}: ${result.error}\n` +
+                    (result.fix ? `  Fix: ${result.fix}\n` : ""));
+                this.notifySnapshotChange(state.snapshot);
+                return;
+            }
+            // Config check passed — clear any prior error so the pulse stops
+            // reporting the broken state. This is the recovery path: the user
+            // fixed their secrets/config, the next startAgent attempt sees a
+            // valid config, and the pulse goes quiet.
+            state.snapshot.errorReason = null;
+            state.snapshot.fixHint = null;
+        }
         const runCwd = (0, identity_1.getRepoRoot)();
         const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
+        if (this.existsSyncFn && !this.existsSyncFn(entryScript)) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_entry_missing",
+                message: "agent entry script does not exist — cannot spawn. Run 'ouro daemon install' from the correct location.",
+                meta: { agent, entryScript },
+            });
+            this.notifySnapshotChange(state.snapshot);
+            return;
+        }
         const args = [entryScript, "--agent", state.config.agentArg ?? agent, ...(state.config.args ?? [])];
         const child = this.spawnFn("node", args, {
             cwd: runCwd,
             env: state.config.env ? { ...process.env, ...state.config.env } : process.env,
             stdio: ["ignore", "ignore", "ignore", "ipc"],
         });
+        /* v8 ignore next 7 -- defensive: spawn should always return a ChildProcess @preserve */
+        if (!child) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "daemon", event: "daemon.agent_spawn_failed", message: "spawn returned null", meta: { agent } });
+            return;
+        }
         state.process = child;
         state.snapshot.status = "running";
         state.snapshot.pid = child.pid ?? null;
@@ -112,6 +222,18 @@ class DaemonProcessManager {
             message: "daemon started managed agent process",
             meta: { agent, pid: child.pid ?? null, cwd: runCwd },
         });
+        this.notifySnapshotChange(state.snapshot);
+        /* v8 ignore start — child process error handler; requires real spawn to trigger */
+        child.on("error", (err) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_process_error",
+                message: "managed agent process emitted error",
+                meta: { agent, error: err.message },
+            });
+        });
+        /* v8 ignore stop */
         child.once("exit", (code, signal) => {
             this.onExit(state, code, signal);
         });
@@ -119,10 +241,12 @@ class DaemonProcessManager {
     async stopAgent(agent) {
         const state = this.requireAgent(agent);
         this.clearRestartTimer(state);
+        this.clearCooldownTimer(state);
         state.stopRequested = true;
         if (!state.process) {
             state.snapshot.status = "stopped";
             state.snapshot.pid = null;
+            this.notifySnapshotChange(state.snapshot);
             return;
         }
         const child = state.process;
@@ -141,6 +265,7 @@ class DaemonProcessManager {
                 meta: { agent },
             });
         }
+        this.notifySnapshotChange(state.snapshot);
     }
     async restartAgent(agent) {
         await this.stopAgent(agent);
@@ -179,6 +304,8 @@ class DaemonProcessManager {
             return;
         state.process = null;
         state.snapshot.pid = null;
+        state.snapshot.lastExitCode = code;
+        state.snapshot.lastSignal = signal;
         const crashed = !state.stopRequested && code !== 0;
         const now = this.now();
         const startedAt = state.snapshot.startedAt ? Date.parse(state.snapshot.startedAt) : now;
@@ -195,13 +322,45 @@ class DaemonProcessManager {
             if (runDuration >= this.stabilityThresholdMs) {
                 state.snapshot.backoffMs = this.initialBackoffMs;
             }
+            this.notifySnapshotChange(state.snapshot);
             return;
         }
         state.snapshot.lastCrashAt = new Date(now).toISOString();
+        // Fast-crash detection: if the agent dies within 5 seconds of starting, it's likely
+        // a configuration issue (missing credentials, bad provider, etc.) not a transient failure.
+        // After 3 consecutive fast crashes, stop retrying and mark as config-failed.
+        const FAST_CRASH_THRESHOLD_MS = 5000;
+        const FAST_CRASH_MAX = 3;
+        if (runDuration < FAST_CRASH_THRESHOLD_MS) {
+            state.fastCrashCount = state.fastCrashCount + 1;
+            if (state.fastCrashCount >= FAST_CRASH_MAX) {
+                state.snapshot.status = "crashed";
+                // Capture the fast-crash diagnosis on the snapshot so it surfaces
+                // via the pulse. The error message is prescriptive: it tells the
+                // user (and their sibling agents) exactly what to do.
+                state.snapshot.errorReason = `agent crashed ${FAST_CRASH_MAX} times within ${FAST_CRASH_THRESHOLD_MS}ms of startup — likely a configuration issue (missing credentials, bad provider).`;
+                state.snapshot.fixHint = `Fix the config and run \`ouro up\` to restart, or check daemon logs for the underlying error.`;
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_config_failure",
+                    message: `agent crashed ${FAST_CRASH_MAX} times within ${FAST_CRASH_THRESHOLD_MS}ms of startup — likely a configuration issue (missing credentials, bad provider). Not retrying. Fix the config and run \`ouro up\` to restart.`,
+                    meta: { agent: state.config.name, fastCrashCount: state.fastCrashCount, avgRunDurationMs: runDuration },
+                });
+                this.notifySnapshotChange(state.snapshot);
+                return; // Don't schedule cooldown recovery — this needs human/agent intervention
+            }
+        }
+        else {
+            // Reset fast-crash counter on a stable run
+            state.fastCrashCount = 0;
+        }
         state.crashTimestamps = state.crashTimestamps.filter((crashTs) => crashTs >= startOfHour(now));
         state.crashTimestamps.push(now);
         if (state.crashTimestamps.length > this.maxRestartsPerHour) {
             state.snapshot.status = "crashed";
+            state.snapshot.errorReason = `agent exceeded restart limit (${this.maxRestartsPerHour}/hr) — entering cooldown`;
+            state.snapshot.fixHint = "investigate why the agent keeps crashing; cooldown will retry shortly";
             (0, runtime_1.emitNervesEvent)({
                 level: "error",
                 component: "daemon",
@@ -209,6 +368,8 @@ class DaemonProcessManager {
                 message: "managed agent exceeded restart limit and is marked crashed",
                 meta: { agent: state.config.name, maxRestartsPerHour: this.maxRestartsPerHour },
             });
+            this.notifySnapshotChange(state.snapshot);
+            this.scheduleCooldownRecovery(state);
             return;
         }
         state.snapshot.status = "starting";
@@ -219,6 +380,7 @@ class DaemonProcessManager {
         state.restartTimer = this.setTimeoutFn(() => {
             void this.startAgent(state.config.name);
         }, waitMs);
+        this.notifySnapshotChange(state.snapshot);
     }
     clearRestartTimer(state) {
         if (state.restartTimer === null)
@@ -226,6 +388,45 @@ class DaemonProcessManager {
         this.clearTimeoutFn(state.restartTimer);
         state.restartTimer = null;
     }
+    scheduleCooldownRecovery(state) {
+        if (state.cooldownRetryCount >= this.maxCooldownRetries) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_permanent_failure",
+                message: "managed agent exhausted all cooldown retries — permanently stopped",
+                meta: { agent: state.config.name, cooldownRetryCount: state.cooldownRetryCount, maxCooldownRetries: this.maxCooldownRetries },
+            });
+            return;
+        }
+        this.clearCooldownTimer(state);
+        state.cooldownTimer = this.setTimeoutFn(() => {
+            state.cooldownRetryCount += 1;
+            state.crashTimestamps = [];
+            state.snapshot.backoffMs = this.initialBackoffMs;
+            state.snapshot.status = "starting";
+            state.snapshot.restartCount += 1;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.agent_cooldown_recovery",
+                message: "attempting cooldown recovery for managed agent",
+                meta: { agent: state.config.name, cooldownRetryCount: state.cooldownRetryCount },
+            });
+            void this.startAgent(state.config.name);
+        }, this.cooldownRecoveryMs);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_cooldown_scheduled",
+            message: `scheduled cooldown recovery in ${this.cooldownRecoveryMs}ms`,
+            meta: { agent: state.config.name, cooldownRecoveryMs: this.cooldownRecoveryMs, cooldownRetryCount: state.cooldownRetryCount },
+        });
+    }
+    clearCooldownTimer(state) {
+        if (state.cooldownTimer === null)
+            return;
+        this.clearTimeoutFn(state.cooldownTimer);
+        state.cooldownTimer = null;
+    }
     requireAgent(agent) {
         const state = this.agents.get(agent);
         if (!state) {