@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.1

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

@@ -0,0 +1,220 @@
+"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.DaemonProcessManager = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function startOfHour(ms) {
+    return ms - 60 * 60 * 1000;
+}
+class DaemonProcessManager {
+    agents = new Map();
+    maxRestartsPerHour;
+    stabilityThresholdMs;
+    initialBackoffMs;
+    maxBackoffMs;
+    spawnFn;
+    now;
+    setTimeoutFn;
+    clearTimeoutFn;
+    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.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));
+        for (const agent of options.agents) {
+            this.agents.set(agent.name, {
+                config: agent,
+                process: null,
+                restartTimer: null,
+                crashTimestamps: [],
+                stopRequested: false,
+                snapshot: {
+                    name: agent.name,
+                    channel: agent.channel,
+                    status: "stopped",
+                    pid: null,
+                    restartCount: 0,
+                    startedAt: null,
+                    lastCrashAt: null,
+                    backoffMs: this.initialBackoffMs,
+                },
+            });
+        }
+    }
+    async startAutoStartAgents() {
+        for (const state of this.agents.values()) {
+            if (state.config.autoStart) {
+                await this.startAgent(state.config.name);
+            }
+        }
+    }
+    async startAgent(agent) {
+        const state = this.requireAgent(agent);
+        if (state.process)
+            return;
+        this.clearRestartTimer(state);
+        state.stopRequested = false;
+        state.snapshot.status = "starting";
+        const runCwd = (0, identity_1.getRepoRoot)();
+        const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
+        const args = [entryScript, "--agent", 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"],
+        });
+        state.process = child;
+        state.snapshot.status = "running";
+        state.snapshot.pid = child.pid ?? null;
+        state.snapshot.startedAt = new Date(this.now()).toISOString();
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_started",
+            message: "daemon started managed agent process",
+            meta: { agent, pid: child.pid ?? null, cwd: runCwd },
+        });
+        child.once("exit", (code, signal) => {
+            this.onExit(state, code, signal);
+        });
+    }
+    async stopAgent(agent) {
+        const state = this.requireAgent(agent);
+        this.clearRestartTimer(state);
+        state.stopRequested = true;
+        if (!state.process) {
+            state.snapshot.status = "stopped";
+            state.snapshot.pid = null;
+            return;
+        }
+        const child = state.process;
+        state.process = null;
+        state.snapshot.status = "stopped";
+        state.snapshot.pid = null;
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_stop_error",
+                message: "failed to send SIGTERM to managed agent",
+                meta: { agent },
+            });
+        }
+    }
+    async restartAgent(agent) {
+        await this.stopAgent(agent);
+        await this.startAgent(agent);
+    }
+    async stopAll() {
+        for (const state of this.agents.values()) {
+            await this.stopAgent(state.config.name);
+        }
+    }
+    getAgentSnapshot(agent) {
+        return this.agents.get(agent)?.snapshot;
+    }
+    listAgentSnapshots() {
+        return [...this.agents.values()].map((state) => state.snapshot);
+    }
+    onExit(state, code, signal) {
+        if (!state.process)
+            return;
+        state.process = null;
+        state.snapshot.pid = null;
+        const crashed = !state.stopRequested && code !== 0;
+        const now = this.now();
+        const startedAt = state.snapshot.startedAt ? Date.parse(state.snapshot.startedAt) : now;
+        const runDuration = Math.max(0, now - startedAt);
+        (0, runtime_1.emitNervesEvent)({
+            level: crashed ? "warn" : "info",
+            component: "daemon",
+            event: "daemon.agent_exit",
+            message: "managed agent process exited",
+            meta: { agent: state.config.name, code, signal, crashed, runDurationMs: runDuration },
+        });
+        if (!crashed) {
+            state.snapshot.status = "stopped";
+            if (runDuration >= this.stabilityThresholdMs) {
+                state.snapshot.backoffMs = this.initialBackoffMs;
+            }
+            return;
+        }
+        state.snapshot.lastCrashAt = new Date(now).toISOString();
+        state.crashTimestamps = state.crashTimestamps.filter((crashTs) => crashTs >= startOfHour(now));
+        state.crashTimestamps.push(now);
+        if (state.crashTimestamps.length > this.maxRestartsPerHour) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_restart_exhausted",
+                message: "managed agent exceeded restart limit and is marked crashed",
+                meta: { agent: state.config.name, maxRestartsPerHour: this.maxRestartsPerHour },
+            });
+            return;
+        }
+        state.snapshot.status = "starting";
+        state.snapshot.restartCount += 1;
+        const waitMs = state.snapshot.backoffMs;
+        state.snapshot.backoffMs = Math.min(state.snapshot.backoffMs * 2, this.maxBackoffMs);
+        this.clearRestartTimer(state);
+        state.restartTimer = this.setTimeoutFn(() => {
+            void this.startAgent(state.config.name);
+        }, waitMs);
+    }
+    clearRestartTimer(state) {
+        if (state.restartTimer === null)
+            return;
+        this.clearTimeoutFn(state.restartTimer);
+        state.restartTimer = null;
+    }
+    requireAgent(agent) {
+        const state = this.agents.get(agent);
+        if (!state) {
+            throw new Error(`Unknown managed agent '${agent}'.`);
+        }
+        return state;
+    }
+}
+exports.DaemonProcessManager = DaemonProcessManager;

package/dist/heart/daemon/runtime-logging.js

@@ -0,0 +1,98 @@
+"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.configureDaemonRuntimeLogger = configureDaemonRuntimeLogger;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const nerves_1 = require("../../nerves");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_RUNTIME_LOGGING = {
+    level: "info",
+    sinks: ["terminal", "ndjson"],
+};
+function isLogLevel(value) {
+    return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function resolveRuntimeLoggingConfig(configPath) {
+    let parsed = null;
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ...DEFAULT_RUNTIME_LOGGING };
+    }
+    if (!parsed || typeof parsed !== "object") {
+        return { ...DEFAULT_RUNTIME_LOGGING };
+    }
+    const candidate = parsed;
+    const level = isLogLevel(candidate.level) ? candidate.level : DEFAULT_RUNTIME_LOGGING.level;
+    const sinks = Array.isArray(candidate.sinks)
+        ? candidate.sinks.filter((entry) => entry === "terminal" || entry === "ndjson")
+        : DEFAULT_RUNTIME_LOGGING.sinks;
+    return {
+        level,
+        sinks: sinks.length > 0 ? [...new Set(sinks)] : [...DEFAULT_RUNTIME_LOGGING.sinks],
+    };
+}
+function configureDaemonRuntimeLogger(processName, options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
+    const config = resolveRuntimeLoggingConfig(configPath);
+    const sinks = config.sinks.map((sinkName) => {
+        if (sinkName === "terminal") {
+            return (0, nerves_1.createTerminalSink)();
+        }
+        const ndjsonPath = path.join(homeDir, ".agentstate", "daemon", "logs", `${processName}.ndjson`);
+        return (0, nerves_1.createNdjsonFileSink)(ndjsonPath);
+    });
+    const logger = (0, nerves_1.createLogger)({
+        level: config.level,
+        sinks,
+    });
+    (0, runtime_1.setRuntimeLogger)(logger);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_logger_configured",
+        message: "configured daemon runtime logger",
+        meta: {
+            processName,
+            level: config.level,
+            sinks: config.sinks,
+            configPath,
+        },
+    });
+}

package/dist/heart/daemon/subagent-installer.js

@@ -0,0 +1,125 @@
+"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.installSubagentsForAvailableCli = installSubagentsForAvailableCli;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const runtime_1 = require("../../nerves/runtime");
+function detectCliBinary(binary) {
+    const result = (0, child_process_1.spawnSync)("which", [binary], { encoding: "utf-8" });
+    if (result.status !== 0)
+        return null;
+    const resolved = result.stdout.trim();
+    return resolved.length > 0 ? resolved : null;
+}
+function listSubagentSources(subagentsDir) {
+    if (!fs.existsSync(subagentsDir))
+        return [];
+    return fs.readdirSync(subagentsDir)
+        .filter((name) => name.endsWith(".md"))
+        .filter((name) => name !== "README.md")
+        .map((name) => path.join(subagentsDir, name))
+        .sort((a, b) => a.localeCompare(b));
+}
+function ensureSymlink(source, target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (fs.existsSync(target)) {
+        const stats = fs.lstatSync(target);
+        if (stats.isSymbolicLink()) {
+            const linkedPath = fs.readlinkSync(target);
+            if (linkedPath === source)
+                return false;
+        }
+        fs.unlinkSync(target);
+    }
+    fs.symlinkSync(source, target);
+    return true;
+}
+async function installSubagentsForAvailableCli(options = {}) {
+    const repoRoot = options.repoRoot ?? path.resolve(__dirname, "..", "..", "..");
+    const homeDir = options.homeDir ?? os.homedir();
+    const which = options.which ?? detectCliBinary;
+    const subagentsDir = path.join(repoRoot, "subagents");
+    const sources = listSubagentSources(subagentsDir);
+    const notes = [];
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.subagent_install_start",
+        message: "starting subagent auto-install",
+        meta: { sources: sources.length },
+    });
+    if (sources.length === 0) {
+        notes.push(`no subagent files found at ${subagentsDir}`);
+        return { claudeInstalled: 0, codexInstalled: 0, notes };
+    }
+    let claudeInstalled = 0;
+    let codexInstalled = 0;
+    const claudePath = which("claude");
+    if (!claudePath) {
+        notes.push("claude CLI not found; skipping subagent install");
+    }
+    else {
+        const claudeAgentsDir = path.join(homeDir, ".claude", "agents");
+        for (const source of sources) {
+            const target = path.join(claudeAgentsDir, path.basename(source));
+            if (ensureSymlink(source, target)) {
+                claudeInstalled += 1;
+            }
+        }
+    }
+    const codexPath = which("codex");
+    if (!codexPath) {
+        notes.push("codex CLI not found; skipping subagent install");
+    }
+    else {
+        const codexSkillsDir = path.join(homeDir, ".codex", "skills");
+        for (const source of sources) {
+            const skillName = path.basename(source, ".md");
+            const target = path.join(codexSkillsDir, skillName, "SKILL.md");
+            if (ensureSymlink(source, target)) {
+                codexInstalled += 1;
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.subagent_install_end",
+        message: "completed subagent auto-install",
+        meta: { claudeInstalled, codexInstalled, notes: notes.length },
+    });
+    return { claudeInstalled, codexInstalled, notes };
+}

package/dist/heart/daemon/task-scheduler.js

@@ -0,0 +1,237 @@
+"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.TaskDrivenScheduler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const parser_1 = require("../../repertoire/tasks/parser");
+function walkMarkdownFiles(root, readdirSync, existsSync, files) {
+    if (!existsSync(root))
+        return;
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            walkMarkdownFiles(fullPath, readdirSync, existsSync, files);
+            continue;
+        }
+        if (entry.name.endsWith(".md")) {
+            files.push(fullPath);
+        }
+    }
+}
+function parseCadence(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    // Cron format (minute hour day month weekday)
+    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
+        return value;
+    }
+    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
+    if (!cadenceMatch)
+        return null;
+    const interval = Number.parseInt(cadenceMatch[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    const unit = cadenceMatch[2];
+    if (unit === "m")
+        return `*/${interval} * * * *`;
+    if (unit === "h")
+        return `0 */${interval} * * *`;
+    return `0 0 */${interval} * *`;
+}
+function parseScheduledAt(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    const minute = date.getUTCMinutes();
+    const hour = date.getUTCHours();
+    const day = date.getUTCDate();
+    const month = date.getUTCMonth() + 1;
+    return `${minute} ${hour} ${day} ${month} *`;
+}
+function removeRuntimeFrontmatter(frontmatter) {
+    const { _isCanonicalFilename, ...clean } = frontmatter;
+    return clean;
+}
+class TaskDrivenScheduler {
+    agents;
+    bundlesRoot;
+    nowIso;
+    existsSync;
+    readFileSync;
+    writeFileSync;
+    readdirSync;
+    jobs = new Map();
+    taskPathByKey = new Map();
+    constructor(options) {
+        this.agents = [...options.agents];
+        this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+        this.nowIso = options.nowIso ?? (() => new Date().toISOString());
+        this.existsSync = options.existsSync ?? fs.existsSync;
+        this.readFileSync = options.readFileSync ?? fs.readFileSync;
+        this.writeFileSync = options.writeFileSync ?? fs.writeFileSync;
+        this.readdirSync = options.readdirSync ?? fs.readdirSync;
+    }
+    start() {
+        void this.reconcile();
+    }
+    stop() {
+        // no long-lived resources; reconciliation is stateless across ticks
+    }
+    listJobs() {
+        return [...this.jobs.values()]
+            .map((job) => ({ id: job.id, schedule: job.schedule, lastRun: job.lastRun }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async triggerJob(jobId) {
+        const job = this.jobs.get(jobId);
+        if (!job) {
+            return { ok: false, message: `unknown scheduled job: ${jobId}` };
+        }
+        await this.recordTaskRun(job.agent, job.taskId);
+        return { ok: true, message: `triggered ${jobId}` };
+    }
+    async reconcile() {
+        const nextJobs = new Map();
+        const nextTaskPaths = new Map();
+        for (const agent of this.agents) {
+            const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
+            const collections = ["one-shots", "ongoing", "habits"];
+            const files = [];
+            for (const collection of collections) {
+                walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
+            }
+            for (const filePath of files) {
+                let task;
+                try {
+                    task = (0, parser_1.parseTaskFile)(this.readFileSync(filePath, "utf-8"), filePath);
+                }
+                catch {
+                    continue;
+                }
+                const taskId = task.stem;
+                nextTaskPaths.set(`${agent}:${taskId}`, filePath);
+                if (task.status === "done")
+                    continue;
+                const cadence = parseCadence(task.frontmatter.cadence);
+                if (cadence) {
+                    const id = `${agent}:${taskId}:cadence`;
+                    nextJobs.set(id, {
+                        id,
+                        agent,
+                        taskId,
+                        schedule: cadence,
+                        lastRun: typeof task.frontmatter.lastRun === "string" ? task.frontmatter.lastRun : null,
+                        command: `ouro poke ${agent} --task ${taskId}`,
+                        taskPath: filePath,
+                    });
+                }
+                const scheduledAt = parseScheduledAt(task.frontmatter.scheduledAt);
+                if (scheduledAt) {
+                    const id = `${agent}:${taskId}:scheduledAt`;
+                    nextJobs.set(id, {
+                        id,
+                        agent,
+                        taskId,
+                        schedule: scheduledAt,
+                        lastRun: typeof task.frontmatter.lastRun === "string" ? task.frontmatter.lastRun : null,
+                        command: `ouro poke ${agent} --task ${taskId}`,
+                        taskPath: filePath,
+                    });
+                }
+            }
+        }
+        this.jobs.clear();
+        for (const [id, job] of nextJobs.entries()) {
+            this.jobs.set(id, job);
+        }
+        this.taskPathByKey.clear();
+        for (const [key, filePath] of nextTaskPaths.entries()) {
+            this.taskPathByKey.set(key, filePath);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.scheduler_reconciled",
+            message: "reconciled task-driven schedule jobs",
+            meta: { jobCount: this.jobs.size, agents: this.agents.length },
+        });
+    }
+    async recordTaskRun(agent, taskId) {
+        const key = `${agent}:${taskId}`;
+        let taskPath = this.taskPathByKey.get(key);
+        if (!taskPath) {
+            await this.reconcile();
+            taskPath = this.taskPathByKey.get(key);
+            if (!taskPath)
+                return;
+        }
+        let parsed;
+        try {
+            parsed = (0, parser_1.parseTaskFile)(this.readFileSync(taskPath, "utf-8"), taskPath);
+        }
+        catch {
+            return;
+        }
+        const now = this.nowIso();
+        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        frontmatter.lastRun = now;
+        if (typeof frontmatter.updated === "string") {
+            frontmatter.updated = now.slice(0, 10);
+        }
+        this.writeFileSync(taskPath, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        for (const job of this.jobs.values()) {
+            if (job.agent === agent && job.taskId === taskId) {
+                job.lastRun = now;
+            }
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.scheduler_task_run_recorded",
+            message: "recorded scheduled task run",
+            meta: { agent, taskId, at: now },
+        });
+    }
+}
+exports.TaskDrivenScheduler = TaskDrivenScheduler;