@ouro.bot/cli 0.1.0-alpha.99 → 0.1.0-alpha.991

package/dist/heart/daemon/bluebubbles-host.js

@@ -0,0 +1,273 @@
+"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;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLUEBUBBLES_LAUNCH_AGENT_LABEL = exports.BLUEBUBBLES_EXECUTABLE_PATH = exports.BLUEBUBBLES_APP_PATH = void 0;
+exports.blueBubblesLaunchAgentPlist = blueBubblesLaunchAgentPlist;
+exports.blueBubblesLaunchAgentPath = blueBubblesLaunchAgentPath;
+exports.inspectBlueBubblesHost = inspectBlueBubblesHost;
+exports.runBlueBubblesHostAction = runBlueBubblesHostAction;
+exports.createDefaultBlueBubblesHostDeps = createDefaultBlueBubblesHostDeps;
+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");
+exports.BLUEBUBBLES_APP_PATH = "/Applications/BlueBubbles.app";
+exports.BLUEBUBBLES_EXECUTABLE_PATH = `${exports.BLUEBUBBLES_APP_PATH}/Contents/MacOS/BlueBubbles`;
+exports.BLUEBUBBLES_LAUNCH_AGENT_LABEL = "com.bluebubbles.server";
+function blueBubblesLaunchAgentPlist(appExecutablePath = exports.BLUEBUBBLES_EXECUTABLE_PATH) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+    <dict>
+        <key>AssociatedBundleIdentifiers</key>
+        <array>
+            <string>com.BlueBubbles.BlueBubbles-Server</string>
+        </array>
+        <key>Label</key>
+        <string>com.bluebubbles.server</string>
+        <key>Program</key>
+        <string>${appExecutablePath}</string>
+        <key>RunAtLoad</key>
+        <true/>
+        <key>KeepAlive</key>
+        <dict>
+	        <key>SuccessfulExit</key>
+	        <false/>
+            <key>Crashed</key>
+            <true/>
+	    </dict>
+    </dict>
+</plist>`;
+}
+function blueBubblesLaunchAgentPath(homeDir) {
+    return path.join(homeDir, "Library", "LaunchAgents", `${exports.BLUEBUBBLES_LAUNCH_AGENT_LABEL}.plist`);
+}
+function requireMacOS(deps) {
+    if (deps.platform !== "darwin")
+        throw new Error("BlueBubbles host lifecycle requires macOS");
+}
+function launchdDomain(deps) {
+    return `gui/${deps.uid}`;
+}
+function serviceTarget(deps) {
+    return `${launchdDomain(deps)}/${exports.BLUEBUBBLES_LAUNCH_AGENT_LABEL}`;
+}
+function requireLaunchctl(result, operation) {
+    if (!result.ok)
+        throw new Error(`launchctl ${operation} failed: ${result.detail}`);
+}
+async function inspectBlueBubblesHost(deps) {
+    requireMacOS(deps);
+    const plistPath = blueBubblesLaunchAgentPath(deps.homeDir);
+    const expectedPlist = blueBubblesLaunchAgentPlist();
+    let plist = "missing";
+    if (deps.existsSync(plistPath)) {
+        try {
+            plist = deps.readFileSync(plistPath) === expectedPlist ? "current" : "drifted";
+        }
+        catch {
+            plist = "drifted";
+        }
+    }
+    const launchd = deps.launchctl(["print", serviceTarget(deps)]);
+    const http = deps.probeHttp
+        ? await deps.probeHttp()
+        : { ok: null, detail: "HTTP health was not configured for this host inspection" };
+    const state = {
+        app: deps.existsSync(exports.BLUEBUBBLES_APP_PATH) ? "present" : "missing",
+        plist,
+        service: launchd.ok ? "loaded" : "not-loaded",
+        serviceDetail: launchd.detail,
+        process: deps.isProcessRunning() ? "running" : "not-running",
+        http,
+        plistPath,
+        launchdDomain: launchdDomain(deps),
+        launchAgentLabel: exports.BLUEBUBBLES_LAUNCH_AGENT_LABEL,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bluebubbles_host_inspected",
+        message: "inspected native BlueBubbles host lifecycle",
+        meta: {
+            app: state.app,
+            plist: state.plist,
+            service: state.service,
+            process: state.process,
+            httpOk: state.http.ok,
+            launchdDomain: state.launchdDomain,
+        },
+    });
+    return state;
+}
+function writeNativePlist(deps, plistPath) {
+    deps.mkdirSync(path.dirname(plistPath), { recursive: true });
+    deps.writeFileSync(plistPath, blueBubblesLaunchAgentPlist(), { mode: 0o644 });
+}
+function reloadNativeService(deps, plistPath, wasLoaded) {
+    const target = serviceTarget(deps);
+    const domain = launchdDomain(deps);
+    if (wasLoaded)
+        requireLaunchctl(deps.launchctl(["bootout", target]), "bootout");
+    requireLaunchctl(deps.launchctl(["disable", target]), "disable");
+    requireLaunchctl(deps.launchctl(["enable", target]), "enable");
+    requireLaunchctl(deps.launchctl(["bootstrap", domain, plistPath]), "bootstrap");
+}
+async function runBlueBubblesHostAction(action, deps) {
+    requireMacOS(deps);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.bluebubbles_host_action_start",
+        message: "starting native BlueBubbles host lifecycle action",
+        meta: { action, uid: deps.uid },
+    });
+    try {
+        const before = await inspectBlueBubblesHost(deps);
+        let changed = false;
+        if (action === "status") {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.bluebubbles_host_action_end",
+                message: "completed native BlueBubbles host lifecycle action",
+                meta: { action, changed: false, service: before.service },
+            });
+            return { action, changed: false, state: before };
+        }
+        if (action === "remove") {
+            if (before.service === "loaded") {
+                requireLaunchctl(deps.launchctl(["disable", serviceTarget(deps)]), "disable");
+                requireLaunchctl(deps.launchctl(["bootout", serviceTarget(deps)]), "bootout");
+                changed = true;
+            }
+            if (before.plist !== "missing") {
+                deps.unlinkSync(before.plistPath);
+                changed = true;
+            }
+            const state = changed ? await inspectBlueBubblesHost(deps) : before;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.bluebubbles_host_action_end",
+                message: "completed native BlueBubbles host lifecycle action",
+                meta: { action, changed, service: state.service },
+            });
+            return { action, changed, state };
+        }
+        if (before.app === "missing") {
+            throw new Error(`BlueBubbles app is missing at ${exports.BLUEBUBBLES_APP_PATH}`);
+        }
+        const needsPlist = before.plist !== "current";
+        if (needsPlist) {
+            writeNativePlist(deps, before.plistPath);
+            changed = true;
+        }
+        if (needsPlist || before.service !== "loaded") {
+            reloadNativeService(deps, before.plistPath, before.service === "loaded");
+            changed = true;
+        }
+        const state = changed ? await inspectBlueBubblesHost(deps) : before;
+        if (state.plist !== "current" || state.service !== "loaded") {
+            throw new Error(`BlueBubbles host postcondition failed: plist=${state.plist}, service=${state.service}`);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.bluebubbles_host_action_end",
+            message: "completed native BlueBubbles host lifecycle action",
+            meta: { action, changed, service: state.service },
+        });
+        return { action, changed, state };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.bluebubbles_host_action_error",
+            level: "error",
+            message: "native BlueBubbles host lifecycle action failed",
+            meta: { action, uid: deps.uid, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+}
+function createDefaultBlueBubblesHostDeps(input = {}) {
+    const serverUrl = input.serverUrl ?? "http://127.0.0.1:1234/";
+    const requestTimeoutMs = input.requestTimeoutMs ?? 30_000;
+    /* v8 ignore next -- production uses global fetch; unit tests inject the adapter @preserve */
+    const fetchImpl = input.fetchImpl ?? fetch;
+    const probeHttp = input.probeHttp ?? (async () => {
+        try {
+            const response = await fetchImpl(serverUrl, {
+                method: "GET",
+                signal: AbortSignal.timeout(requestTimeoutMs),
+            });
+            return { ok: true, detail: `HTTP server responded with ${response.status}` };
+        }
+        catch (error) {
+            return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        }
+    });
+    return {
+        platform: process.platform,
+        homeDir: os.homedir(),
+        uid: process.getuid?.() ?? 0,
+        existsSync: fs.existsSync,
+        readFileSync: (filePath) => fs.readFileSync(filePath, "utf8"),
+        mkdirSync: fs.mkdirSync,
+        writeFileSync: (filePath, content, options) => fs.writeFileSync(filePath, content, options),
+        unlinkSync: fs.unlinkSync,
+        launchctl: (args) => {
+            try {
+                const stdout = (0, child_process_1.execFileSync)("launchctl", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+                return { ok: true, detail: stdout.trim() || "ok" };
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                return { ok: false, detail };
+            }
+        },
+        isProcessRunning: () => {
+            try {
+                (0, child_process_1.execFileSync)("pgrep", ["-f", exports.BLUEBUBBLES_EXECUTABLE_PATH], { stdio: "ignore" });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        probeHttp,
+    };
+}
+__exportStar(require("./bluebubbles-host-protocol"), exports);

package/dist/heart/daemon/boot-sync-probe.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * Boot sync probe — Layer 2 orchestrator for `ouro up`.
+ *
+ * For each sync-enabled bundle, runs `probeSync` (fetch only, then count
+ * commits ahead and behind) wrapped in `runWithTimeouts`, classifies failures
+ * via `classifySyncFailure`, and returns aggregated findings plus one status
+ * per probed bundle. Both surface in the boot stdout summary written by
+ * `cli-exec.ts` after the probe phase.
+ *
+ * Layer 2 is intentionally a **boot-time preflight surface only** — it
+ * does NOT feed into the running daemon's rollup state. `computeDaemonRollup`
+ * is unaware of these findings; nothing is persisted to daemon health for
+ * the running daemon to consume. Layer 3 RepairGuide is the planned consumer
+ * (it reads the in-memory `BootSyncProbeFinding[]` at boot time and
+ * dispatches the right diagnostic skill).
+ *
+ * The probe NEVER:
+ *   - Merges, commits or pushes: it fetches only.
+ *   - Waits for the bundle sync lock: a held lock is reported as busy.
+ *   - Writes to `state/` (verified by Unit 7's grep gate).
+ *   - Throws — every failure becomes a finding.
+ *   - Hangs — `AbortSignal` from `runWithTimeouts` cuts hung remotes
+ *     within `hardMs`.
+ *
+ * Advisory vs blocking classifications (consumed by layer 3, not by the
+ * layer 1 rollup — see comment above):
+ *
+ *   | classification         | advisory? | rationale                                   |
+ *   | ---------------------- | --------- | ------------------------------------------- |
+ *   | auth-failed            | no        | agent can't sync; needs human intervention  |
+ *   | not-found-404          | no        | remote is gone; needs human intervention    |
+ *   | network-down           | no        | agent can't reach the remote at all         |
+ *   | timeout-hard           | no        | abort cut the op; remote is hung            |
+ *   | dirty-working-tree     | yes       | local edits prevent merge; agent still runs |
+ *   | non-fast-forward       | yes       | local commits ahead; agent still runs       |
+ *   | merge-conflict         | yes       | rebase failed; needs cleanup                |
+ *   | timeout-soft           | yes       | warning surfaced, op completed              |
+ *   | unknown                | yes       | unrecognised; surface for diagnosis         |
+ *
+ * `advisory: true` is a hint for layer 3 ("warn-and-continue, agent likely
+ * still works") vs `advisory: false` ("blocking, agent can't sync until
+ * fixed"). Layer 3 will route the right diagnostic skill on this signal.
+ */
+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.runBootSyncProbe = runBootSyncProbe;
+const path = __importStar(require("path"));
+const sync_1 = require("../sync");
+const sync_lock_1 = require("../sync-lock");
+const sync_classification_1 = require("../sync-classification");
+const timeouts_1 = require("../timeouts");
+const runtime_1 = require("../../nerves/runtime");
+/** Default soft / hard timeout windows for the boot git op. Matches Layer 2 O1 lock. */
+const DEFAULT_SOFT_MS = 8000;
+const DEFAULT_HARD_MS = 15000;
+const BLOCKING_CLASSIFICATIONS = new Set([
+    "auth-failed",
+    "not-found-404",
+    "network-down",
+    "timeout-hard",
+]);
+function isAdvisory(classification) {
+    return !BLOCKING_CLASSIFICATIONS.has(classification);
+}
+/**
+ * Probe sync state for every enabled, git-initialised bundle. Returns
+ * findings for every non-clean result. Probes run sequentially (not in
+ * parallel) so the boot path's progress reporter has a stable per-agent
+ * narrative; the per-probe hard cap means worst-case total wait is
+ * `bundles.length * hardMs`, which is acceptable for typical 1-3 agent
+ * deployments.
+ */
+async function runBootSyncProbe(bundles, options) {
+    const startedAt = Date.now();
+    const softMs = options.softMs ?? DEFAULT_SOFT_MS;
+    const hardMs = options.hardMs ?? DEFAULT_HARD_MS;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.boot_sync_probe_start",
+        message: "boot sync probe starting",
+        meta: { bundleCount: bundles.length, softMs, hardMs },
+    });
+    const findings = [];
+    const statuses = [];
+    for (const bundle of bundles) {
+        if (!bundle.enabled)
+            continue;
+        const agentRoot = path.join(options.bundlesRoot, `${bundle.agent}.ouro`);
+        // gitInitialized=false: bundle is enabled for sync but never had `git init`.
+        // Surface as advisory finding without invoking git.
+        if (bundle.gitInitialized === false) {
+            findings.push({
+                agent: bundle.agent,
+                classification: "unknown",
+                error: sync_1.NOT_A_REPO_ERROR,
+                conflictFiles: [],
+                warnings: [],
+                advisory: true,
+            });
+            continue;
+        }
+        const syncConfig = { enabled: bundle.enabled, remote: bundle.remote, branch: bundle.branch };
+        // A lock this pid left in an earlier life (PID 1 in the container) would read as busy forever.
+        try {
+            (0, sync_lock_1.clearOwnStaleSyncLock)(agentRoot);
+        }
+        catch {
+            // An unreadable lock is reported by the probe's own attempt below.
+        }
+        const outcome = await (0, timeouts_1.runWithTimeouts)((signal) => (0, sync_1.probeSync)(agentRoot, syncConfig, signal), { softMs, hardMs, label: `boot-sync-probe ${bundle.agent}`, envKey: "GIT" });
+        // Hard timeout — the probe was aborted. Synthesise a finding from the
+        // outcome's classification (the underlying `probeSync` may also
+        // have rejected with an AbortError, but the wrapper already swallowed
+        // it).
+        if (outcome.classification === "timeout-hard") {
+            findings.push({
+                agent: bundle.agent,
+                classification: "timeout-hard",
+                error: `boot sync probe for ${bundle.agent} aborted after ${hardMs}ms hard timeout`,
+                conflictFiles: [],
+                warnings: outcome.warnings,
+                advisory: isAdvisory("timeout-hard"),
+            });
+            continue;
+        }
+        const result = outcome.result;
+        /* v8 ignore start -- defensive: exclusive state from runWithTimeouts contract — either result or classification, never both undefined @preserve */
+        if (!result) {
+            findings.push({
+                agent: bundle.agent,
+                classification: "unknown",
+                error: "boot sync probe returned without result or classification",
+                conflictFiles: [],
+                warnings: outcome.warnings,
+                advisory: true,
+            });
+            continue;
+        }
+        /* v8 ignore stop */
+        if (!result.ok) {
+            const classification = (0, sync_classification_1.classifySyncFailure)(new Error(result.error ?? "unknown sync error"), { agentRoot });
+            findings.push({
+                agent: bundle.agent,
+                classification: classification.classification,
+                error: classification.error,
+                conflictFiles: classification.conflictFiles,
+                warnings: outcome.warnings,
+                advisory: isAdvisory(classification.classification),
+            });
+            continue;
+        }
+        const status = describeProbeResult(result, syncConfig);
+        if (status)
+            statuses.push({ agent: bundle.agent, text: status });
+        // Probe succeeded. If the soft warning fired, surface it as an advisory
+        // finding so the operator sees the slow-pull warning even on success.
+        if (outcome.warnings.length > 0) {
+            findings.push({
+                agent: bundle.agent,
+                classification: "timeout-soft",
+                error: outcome.warnings.join("; "),
+                conflictFiles: [],
+                warnings: outcome.warnings,
+                advisory: true,
+            });
+        }
+    }
+    // Stable order — sort by agent name so renderers and tests see the same
+    // sequence.
+    findings.sort((a, b) => a.agent.localeCompare(b.agent));
+    statuses.sort((a, b) => a.agent.localeCompare(b.agent));
+    const durationMs = Date.now() - startedAt;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.boot_sync_probe_end",
+        message: "boot sync probe complete",
+        meta: { findingCount: findings.length, statusCount: statuses.length, durationMs },
+    });
+    return { findings, statuses, durationMs };
+}
+/** The probe's view of one healthy bundle, or null when there is nothing to say (no remote). */
+function describeProbeResult(result, config) {
+    if (result.paused)
+        return `sync paused until ${result.pausedUntil}`;
+    if (result.busy)
+        return `sync busy: another sync holds the lock${result.holderPid == null ? "" : ` (pid ${result.holderPid})`}`;
+    if (result.ahead === undefined || result.behind === undefined)
+        return null;
+    return `${result.ahead} ahead, ${result.behind} behind ${config.remote}/${config.branch}`;
+}

package/dist/heart/daemon/cadence.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CADENCE_MS = void 0;
+exports.parseCadenceToCron = parseCadenceToCron;
+exports.parseCadenceToMs = parseCadenceToMs;
+exports.nextCadenceRunAt = nextCadenceRunAt;
+exports.cadenceFallbackDelayMs = cadenceFallbackDelayMs;
+exports.evaluateCadenceDue = evaluateCadenceDue;
+const runtime_1 = require("../../nerves/runtime");
+exports.DEFAULT_CADENCE_MS = 30 * 60 * 1000; // 30 minutes
+function parseFixedDailyCron(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const parts = raw.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const minuteRaw = parts[0];
+    const hourRaw = parts[1];
+    const day = parts[2];
+    const month = parts[3];
+    const weekday = parts[4];
+    if (day !== "*" || month !== "*" || weekday !== "*")
+        return null;
+    if (!/^\d+$/.test(minuteRaw) || !/^\d+$/.test(hourRaw))
+        return null;
+    const minute = Number.parseInt(minuteRaw, 10);
+    const hour = Number.parseInt(hourRaw, 10);
+    if (minute < 0 || minute > 59 || hour < 0 || hour > 23)
+        return null;
+    return { minute, hour };
+}
+function coerceTimeMs(value) {
+    const time = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(value);
+    return Number.isFinite(time) ? time : null;
+}
+function localOccurrenceForDay(referenceMs, fixed) {
+    const occurrence = new Date(referenceMs);
+    occurrence.setHours(fixed.hour, fixed.minute, 0, 0);
+    return occurrence;
+}
+function previousFixedDailyOccurrence(fixed, nowMs) {
+    const occurrence = localOccurrenceForDay(nowMs, fixed);
+    if (occurrence.getTime() > nowMs) {
+        occurrence.setDate(occurrence.getDate() - 1);
+    }
+    return occurrence;
+}
+function nextFixedDailyOccurrence(fixed, fromMs) {
+    const occurrence = localOccurrenceForDay(fromMs, fixed);
+    if (occurrence.getTime() <= fromMs) {
+        occurrence.setDate(occurrence.getDate() + 1);
+    }
+    return occurrence;
+}
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into a cron string.
+ * Also accepts raw cron strings (5 space-separated fields) and passes them through.
+ * Returns null for invalid input.
+ */
+function parseCadenceToCron(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;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed",
+        component: "daemon",
+        message: "parsed cadence shorthand to cron",
+        meta: { raw: value, interval, unit: cadenceMatch[2] },
+    });
+    const unit = cadenceMatch[2];
+    if (unit === "m")
+        return `*/${interval} * * * *`;
+    if (unit === "h")
+        return `0 */${interval} * * *`;
+    return `0 0 */${interval} * *`;
+}
+/**
+ * Parse a cadence shorthand (e.g. "30m", "2h", "1d") into milliseconds.
+ * Returns null for invalid input.
+ */
+function parseCadenceToMs(raw) {
+    if (typeof raw !== "string")
+        return null;
+    const value = raw.trim();
+    if (!value)
+        return null;
+    const match = /^(\d+)(m|h|d)$/.exec(value);
+    if (!match)
+        return null;
+    const interval = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(interval) || interval <= 0)
+        return null;
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.cadence_parsed_ms",
+        component: "daemon",
+        message: "parsed cadence shorthand to milliseconds",
+        meta: { raw: value, interval, unit: match[2] },
+    });
+    const unit = match[2];
+    if (unit === "m")
+        return interval * 60 * 1000;
+    if (unit === "h")
+        return interval * 60 * 60 * 1000;
+    return interval * 24 * 60 * 60 * 1000;
+}
+function nextCadenceRunAt(raw, from) {
+    const fromMs = coerceTimeMs(from);
+    if (fromMs === null)
+        return null;
+    const intervalMs = parseCadenceToMs(raw);
+    if (intervalMs !== null) {
+        return new Date(fromMs + intervalMs).toISOString();
+    }
+    const fixed = parseFixedDailyCron(raw);
+    if (!fixed)
+        return null;
+    const next = nextFixedDailyOccurrence(fixed, fromMs);
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.fixed_cadence_next_run_computed",
+        component: "daemon",
+        message: "computed fixed daily cadence next run",
+        meta: { raw, nextRunAt: next.toISOString() },
+    });
+    return next.toISOString();
+}
+function cadenceFallbackDelayMs(raw, nowMs) {
+    const intervalMs = parseCadenceToMs(raw);
+    if (intervalMs !== null)
+        return intervalMs;
+    const nextRunAt = nextCadenceRunAt(raw, nowMs);
+    if (!nextRunAt)
+        return null;
+    const delay = Date.parse(nextRunAt) - nowMs;
+    return delay;
+}
+function evaluateCadenceDue(raw, lastRun, nowMs) {
+    const intervalMs = parseCadenceToMs(raw);
+    if (intervalMs !== null) {
+        if (lastRun === null) {
+            return { due: true, elapsedMs: Infinity, occurrenceId: `overdue:first-run:${String(raw).trim()}` };
+        }
+        const lastRunMs = Date.parse(lastRun);
+        if (!Number.isFinite(lastRunMs))
+            return { due: false, elapsedMs: 0, occurrenceId: null };
+        const elapsedMs = nowMs - lastRunMs;
+        return {
+            due: elapsedMs >= intervalMs,
+            elapsedMs,
+            occurrenceId: elapsedMs >= intervalMs ? `overdue:last-run:${lastRun}:cadence:${String(raw).trim()}` : null,
+        };
+    }
+    const fixed = parseFixedDailyCron(raw);
+    if (!fixed)
+        return null;
+    const occurrence = previousFixedDailyOccurrence(fixed, nowMs);
+    const elapsedMs = lastRun === null ? Infinity : nowMs - occurrence.getTime();
+    const todayOccurrence = localOccurrenceForDay(nowMs, fixed);
+    const hasReachedTodayOccurrence = todayOccurrence.getTime() <= nowMs;
+    const lastRunMs = lastRun === null ? null : Date.parse(lastRun);
+    const due = lastRunMs === null
+        ? hasReachedTodayOccurrence
+        : Number.isFinite(lastRunMs) && lastRunMs < occurrence.getTime();
+    return {
+        due,
+        elapsedMs,
+        occurrenceId: due ? `fixed-daily:${occurrence.toISOString()}:cadence:${String(raw).trim()}` : null,
+    };
+}