@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_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.698",
+      "changes": [
+        "Open the daemon socket before provider credential warm-up and preload only configured lane providers so slow vault reads cannot make ouro up falsely report a dead daemon.",
+        "Require explicitly selected provider credential refreshes to load every requested provider before replacing cached provider state.",
+        "Return structured RSVP smoke guidance when the latest snapshot is missing or invalid, with hermetic CLI coverage that cannot send live BlueBubbles messages from tests.",
+        "Keep native RSVP update notifications on the legacy message skeleton while replacing only the obsolete script-vs-Slugger footer copy."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.697",
+      "changes": [
+        "Add BlueBubbles same-thread context, native RSVP habit, autonomy budgets, run ledger attribution, diagnostics, cutover, and verification guardrails.",
+        "Harden Twilio phone agent-root resolution so test and runtime callers use explicit bundle roots without falling back to the host AgentBundles tree.",
+        "Gate native RSVP live sends on a current passing legacy cutover check so refreshes and smoke tests cannot compete with the old RSVP sender.",
+        "Align RSVP doctor cutover preflight with the native config's legacy root so triage reports the same sender state enforced by live sends."
+      ]
+    },
     {
       "version": "0.1.0-alpha.696",
       "changes": [

package/dist/heart/agent-entry.js

@@ -119,6 +119,35 @@ if (!ipcState.installed) {
     message: "starting private-runtime process entrypoint",
     meta: { entry: "private-runtime", agentName },
 });
+async function selectedProviderTargets(agentName) {
+    try {
+        const [{ readAgentConfigForAgent }, { getAgentBundlesRoot }] = await Promise.all([
+            Promise.resolve().then(() => __importStar(require("./auth/auth-flow"))),
+            Promise.resolve().then(() => __importStar(require("./identity"))),
+        ]);
+        const { config } = readAgentConfigForAgent(agentName, getAgentBundlesRoot());
+        return [...new Set([config.humanFacing.provider, config.agentFacing.provider])];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.provider_refresh_skipped",
+            message: "skipping private-runtime provider credential refresh because agent config could not be read",
+            meta: {
+                entry: "private-runtime",
+                agentName,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error agent-config failures @preserve */ String(error),
+            },
+        });
+        return [];
+    }
+}
+function providerPoolMissingTargets(providerPool, providers) {
+    if (!providerPool.ok)
+        return true;
+    return providers.some((provider) => !providerPool.pool.providers[provider]);
+}
 // Dynamic import: agent-entry is process-start wiring that starts a sense process.
 // Using dynamic import avoids a static heart/ -> senses/ dependency.
 Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).then(async ({ readMachineRuntimeCredentialConfig, readRuntimeCredentialConfig, refreshMachineRuntimeCredentialConfig, refreshRuntimeCredentialConfig, applyRuntimeCredentialBootstrapMessage, waitForRuntimeCredentialBootstrap, }) => {
@@ -135,8 +164,9 @@ Promise.resolve().then(() => __importStar(require("./runtime-credentials"))).the
         void refreshRuntimeCredentialConfig(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
     }
     const providerPool = readProviderCredentialPool(agentName);
-    if (!providerPool.ok || Object.keys(providerPool.pool.providers).length === 0) {
-        await refreshProviderCredentialPool(agentName, { preserveCachedOnFailure: true }).catch(() => undefined);
+    const providerTargets = await selectedProviderTargets(agentName);
+    if (providerTargets.length > 0 && providerPoolMissingTargets(providerPool, providerTargets)) {
+        await refreshProviderCredentialPool(agentName, { preserveCachedOnFailure: true, providers: providerTargets }).catch(() => undefined);
     }
     /* v8 ignore next 7 -- process-start best-effort machine credential refresh runs in a child entrypoint and is covered operationally by daemon startup tests @preserve */
     if (!readMachineRuntimeCredentialConfig(agentName).ok) {

package/dist/heart/autonomy-budget.js

@@ -0,0 +1,434 @@
+"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.AUTONOMY_BUDGET_DEFAULT_POLICY = void 0;
+exports.autonomyBudgetStatePath = autonomyBudgetStatePath;
+exports.autonomyReceiptsDir = autonomyReceiptsDir;
+exports.readAutonomyBudgetState = readAutonomyBudgetState;
+exports.readAutonomyStormBreakers = readAutonomyStormBreakers;
+exports.reserveAutonomyBudget = reserveAutonomyBudget;
+exports.recordAutonomyFailure = recordAutonomyFailure;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const run_ledger_1 = require("./run-ledger");
+exports.AUTONOMY_BUDGET_DEFAULT_POLICY = {
+    agentProactivePaidTurnsPerHour: 6,
+    agentProactivePaidTurnsPerDay: 40,
+    senseRecoveryPaidTurnsPer15m: 3,
+    senseRecoveryPaidTurnsPerDay: 12,
+    habitPaidTurnsPerDay: 4,
+    duplicateRecoveryTtlMs: 10 * 60 * 1000,
+    duplicateHabitTtlMs: 24 * 60 * 60 * 1000,
+    stormFailureThreshold: 3,
+    stormFailureWindowMs: 10 * 60 * 1000,
+    stormBlockMs: 30 * 60 * 1000,
+};
+function autonomyRoot(agentRoot) {
+    return path.join(agentRoot, "state", "autonomy");
+}
+function autonomyBudgetStatePath(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "budgets.json");
+}
+function autonomyReceiptsDir(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "receipts");
+}
+function stormBreakersPath(agentRoot) {
+    return path.join(autonomyRoot(agentRoot), "storm-breakers.jsonl");
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function parseMs(value) {
+    return Date.parse(value);
+}
+function sameCivilDay(left, right) {
+    return left.slice(0, 10) === right.slice(0, 10);
+}
+function emptyState() {
+    return {
+        schemaVersion: 1,
+        updatedAt: new Date().toISOString(),
+        reservations: [],
+        failures: [],
+    };
+}
+function isReservation(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.reservedAt === "string"
+        && (row.status === undefined || row.status === "reserved" || row.status === "failed")
+        && typeof row.agent === "string"
+        && typeof row.triggerType === "string"
+        && typeof row.sourceKind === "string"
+        && typeof row.senseOrHabit === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.idempotencyKey === "string"
+        && row.contentStored === false;
+}
+function isFailure(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.occurredAt === "string"
+        && typeof row.fingerprint === "string"
+        && typeof row.agent === "string"
+        && typeof row.triggerType === "string"
+        && typeof row.sourceKind === "string"
+        && typeof row.senseOrHabit === "string"
+        && typeof row.provider === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.normalizedErrorName === "string"
+        && typeof row.normalizedErrorCode === "string"
+        && typeof row.codeLocation === "string"
+        && typeof row.idempotencyBucket === "string"
+        && row.contentStored === false;
+}
+function readAutonomyBudgetState(agentRoot) {
+    const filePath = autonomyBudgetStatePath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyState();
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        return {
+            schemaVersion: 1,
+            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
+            reservations: Array.isArray(parsed.reservations) ? parsed.reservations.filter(isReservation) : [],
+            failures: Array.isArray(parsed.failures) ? parsed.failures.filter(isFailure) : [],
+        };
+    }
+    catch {
+        return emptyState();
+    }
+}
+function writeAutonomyBudgetState(agentRoot, state) {
+    const filePath = autonomyBudgetStatePath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+function receiptIdFor(input) {
+    return `autr_${(0, run_ledger_1.runLedgerHash)(input).slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function writeReceipt(agentRoot, decision) {
+    const receiptId = receiptIdFor(decision);
+    const receipt = {
+        schemaVersion: 1,
+        receiptId,
+        status: decision.status,
+        reason: decision.reason,
+        actor: decision.actor,
+        decidedAt: decision.decidedAt,
+        agent: decision.agent,
+        triggerType: decision.triggerType,
+        sourceKind: decision.sourceKind,
+        senseOrHabit: decision.senseOrHabit,
+        targetHash: decision.targetHash,
+        idempotencyKey: decision.idempotencyKey,
+        contentStored: false,
+    };
+    const filePath = path.join(autonomyReceiptsDir(agentRoot), `${receiptId}.json`);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(receipt, null, 2)}\n`, "utf-8");
+    return receipt;
+}
+function duplicateTtlMs(triggerType, policy) {
+    if (triggerType === "habit")
+        return policy.duplicateHabitTtlMs;
+    return policy.duplicateRecoveryTtlMs;
+}
+function paidAutonomyTrigger(triggerType) {
+    return triggerType === "proactive" || triggerType === "recovery" || triggerType === "habit" || triggerType === "reload";
+}
+function inWindow(at, now, windowMs) {
+    const atMs = parseMs(at);
+    const nowMs = parseMs(now);
+    return Number.isFinite(atMs) && Number.isFinite(nowMs) && nowMs - atMs >= 0 && nowMs - atMs <= windowMs;
+}
+function reservationFor(request, decidedAt) {
+    return {
+        schemaVersion: 1,
+        reservedAt: decidedAt,
+        status: "reserved",
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash: (0, run_ledger_1.runLedgerHash)(request.target),
+        idempotencyKey: request.idempotencyKey,
+        contentStored: false,
+    };
+}
+function stormFingerprint(input) {
+    return (0, run_ledger_1.runLedgerHash)({
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        provider: input.provider,
+        targetHash: (0, run_ledger_1.runLedgerHash)(input.target),
+        normalizedErrorName: input.normalizedErrorName,
+        normalizedErrorCode: input.normalizedErrorCode,
+        codeLocation: input.codeLocation,
+        idempotencyBucket: input.idempotencyBucket,
+    });
+}
+function failureRecord(input, occurredAt) {
+    return {
+        schemaVersion: 1,
+        occurredAt,
+        fingerprint: stormFingerprint(input),
+        agent: input.agent,
+        triggerType: input.triggerType,
+        sourceKind: input.sourceKind,
+        senseOrHabit: input.senseOrHabit,
+        provider: input.provider,
+        targetHash: (0, run_ledger_1.runLedgerHash)(input.target),
+        normalizedErrorName: input.normalizedErrorName,
+        normalizedErrorCode: input.normalizedErrorCode,
+        codeLocation: input.codeLocation,
+        idempotencyBucket: input.idempotencyBucket,
+        contentStored: false,
+    };
+}
+function readAutonomyStormBreakers(agentRoot) {
+    const filePath = stormBreakersPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return [];
+    return fs.readFileSync(filePath, "utf-8")
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            return parsed.schemaVersion === 1 && parsed.contentStored === false ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function appendStormBreaker(agentRoot, breaker) {
+    const filePath = stormBreakersPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(breaker)}\n`, "utf-8");
+}
+function activeStormBreaker(agentRoot, input, now) {
+    const fingerprint = stormFingerprint(input);
+    const nowMs = parseMs(now);
+    return readAutonomyStormBreakers(agentRoot)
+        .filter((breaker) => breaker.fingerprint === fingerprint)
+        .filter((breaker) => parseMs(breaker.blockedUntil) > nowMs)
+        .sort((left, right) => right.blockedAt.localeCompare(left.blockedAt))[0] ?? null;
+}
+function blockDecision(agentRoot, request, decidedAt, status, reason) {
+    const targetHash = (0, run_ledger_1.runLedgerHash)(request.target);
+    const base = {
+        status,
+        actor: "agent-runnable",
+        reason,
+        decidedAt,
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash,
+        idempotencyKey: request.idempotencyKey,
+    };
+    const receipt = writeReceipt(agentRoot, base);
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "heart",
+        event: "heart.autonomy_budget_blocked",
+        message: "autonomy trigger blocked before paid work",
+        meta: {
+            agent: request.agent,
+            triggerType: request.triggerType,
+            sourceKind: request.sourceKind,
+            senseOrHabit: request.senseOrHabit,
+            status,
+            reason,
+            receiptId: receipt.receiptId,
+        },
+    });
+    return { allowed: false, ...base, receiptId: receipt.receiptId };
+}
+function budgetBlockReason(state, request, now, policy) {
+    if (!paidAutonomyTrigger(request.triggerType))
+        return null;
+    const agentRecentHour = state.reservations.filter((row) => row.agent === request.agent
+        && paidAutonomyTrigger(row.triggerType)
+        && inWindow(row.reservedAt, now, 60 * 60 * 1000)).length;
+    if (agentRecentHour >= policy.agentProactivePaidTurnsPerHour)
+        return "agent proactive paid turn budget exceeded for rolling hour";
+    const agentToday = state.reservations.filter((row) => row.agent === request.agent
+        && paidAutonomyTrigger(row.triggerType)
+        && sameCivilDay(row.reservedAt, now)).length;
+    if (agentToday >= policy.agentProactivePaidTurnsPerDay)
+        return "agent proactive paid turn budget exceeded for day";
+    if (request.triggerType === "recovery" && request.sourceKind === "sense") {
+        const recentRecovery = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "recovery"
+            && row.sourceKind === request.sourceKind
+            && row.senseOrHabit === request.senseOrHabit
+            && inWindow(row.reservedAt, now, 15 * 60 * 1000)).length;
+        if (recentRecovery >= policy.senseRecoveryPaidTurnsPer15m)
+            return "sense recovery paid turn budget exceeded for rolling 15 minutes";
+        const recoveryToday = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "recovery"
+            && row.sourceKind === request.sourceKind
+            && row.senseOrHabit === request.senseOrHabit
+            && sameCivilDay(row.reservedAt, now)).length;
+        if (recoveryToday >= policy.senseRecoveryPaidTurnsPerDay)
+            return "sense recovery paid turn budget exceeded for day";
+    }
+    if (request.triggerType === "habit") {
+        const habitToday = state.reservations.filter((row) => row.agent === request.agent
+            && row.triggerType === "habit"
+            && row.senseOrHabit === request.senseOrHabit
+            && sameCivilDay(row.reservedAt, now)).length;
+        if (habitToday >= policy.habitPaidTurnsPerDay)
+            return "habit paid turn budget exceeded for day";
+    }
+    return null;
+}
+function reserveAutonomyBudget(agentRoot, request, policy = exports.AUTONOMY_BUDGET_DEFAULT_POLICY) {
+    const decidedAt = nowIso(request.now);
+    const state = readAutonomyBudgetState(agentRoot);
+    const targetHash = (0, run_ledger_1.runLedgerHash)(request.target);
+    const duplicate = state.reservations.find((row) => row.idempotencyKey === request.idempotencyKey
+        && row.status !== "failed"
+        && inWindow(row.reservedAt, decidedAt, duplicateTtlMs(request.triggerType, policy)));
+    if (duplicate)
+        return blockDecision(agentRoot, request, decidedAt, "duplicate", "duplicate trigger suppressed");
+    if (request.storm && activeStormBreaker(agentRoot, request.storm, decidedAt)) {
+        return blockDecision(agentRoot, request, decidedAt, "blocked", "storm breaker active for this trigger fingerprint");
+    }
+    const reason = budgetBlockReason(state, request, decidedAt, policy);
+    if (reason)
+        return blockDecision(agentRoot, request, decidedAt, "blocked", reason);
+    const reservation = reservationFor(request, decidedAt);
+    const nextState = {
+        schemaVersion: 1,
+        updatedAt: decidedAt,
+        reservations: [...state.reservations, reservation],
+        failures: state.failures,
+    };
+    writeAutonomyBudgetState(agentRoot, nextState);
+    (0, runtime_1.emitNervesEvent)({
+        component: "heart",
+        event: "heart.autonomy_budget_allowed",
+        message: "autonomy trigger reserved budget before paid work",
+        meta: {
+            agent: request.agent,
+            triggerType: request.triggerType,
+            sourceKind: request.sourceKind,
+            senseOrHabit: request.senseOrHabit,
+            targetHash,
+        },
+    });
+    return {
+        allowed: true,
+        status: "allowed",
+        actor: "agent-runnable",
+        reason: "budget reserved",
+        decidedAt,
+        agent: request.agent,
+        triggerType: request.triggerType,
+        sourceKind: request.sourceKind,
+        senseOrHabit: request.senseOrHabit,
+        targetHash,
+        idempotencyKey: request.idempotencyKey,
+    };
+}
+function recordAutonomyFailure(agentRoot, input, policy = exports.AUTONOMY_BUDGET_DEFAULT_POLICY) {
+    const occurredAt = nowIso(input.occurredAt);
+    const record = failureRecord(input, occurredAt);
+    const state = readAutonomyBudgetState(agentRoot);
+    const targetHash = (0, run_ledger_1.runLedgerHash)(input.target);
+    const reservations = state.reservations.map((row) => row.agent === input.agent
+        && row.triggerType === input.triggerType
+        && row.sourceKind === input.sourceKind
+        && row.senseOrHabit === input.senseOrHabit
+        && row.targetHash === targetHash
+        && row.status !== "failed"
+        ? { ...row, status: "failed" }
+        : row);
+    const nextFailures = [...state.failures, record];
+    writeAutonomyBudgetState(agentRoot, {
+        schemaVersion: 1,
+        updatedAt: occurredAt,
+        reservations,
+        failures: nextFailures,
+    });
+    const recent = nextFailures.filter((row) => row.fingerprint === record.fingerprint
+        && inWindow(row.occurredAt, occurredAt, policy.stormFailureWindowMs));
+    if (recent.length >= policy.stormFailureThreshold && !activeStormBreaker(agentRoot, input, occurredAt)) {
+        const breaker = {
+            schemaVersion: 1,
+            fingerprint: record.fingerprint,
+            agent: record.agent,
+            triggerType: record.triggerType,
+            sourceKind: record.sourceKind,
+            senseOrHabit: record.senseOrHabit,
+            provider: record.provider,
+            targetHash: record.targetHash,
+            normalizedErrorName: record.normalizedErrorName,
+            normalizedErrorCode: record.normalizedErrorCode,
+            codeLocation: record.codeLocation,
+            idempotencyBucket: record.idempotencyBucket,
+            blockedAt: occurredAt,
+            blockedUntil: new Date(parseMs(occurredAt) + policy.stormBlockMs).toISOString(),
+            failureCount: recent.length,
+            contentStored: false,
+        };
+        appendStormBreaker(agentRoot, breaker);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "heart",
+            event: "heart.autonomy_storm_breaker",
+            message: "autonomy storm breaker activated",
+            meta: {
+                agent: breaker.agent,
+                triggerType: breaker.triggerType,
+                sourceKind: breaker.sourceKind,
+                senseOrHabit: breaker.senseOrHabit,
+                blockedUntil: breaker.blockedUntil,
+                failureCount: breaker.failureCount,
+            },
+        });
+    }
+    return record;
+}

package/dist/heart/core.js

@@ -21,6 +21,7 @@ const friends_1 = require("@ouro.bot/friends");
 const tools_2 = require("../repertoire/tools");
 const runtime_1 = require("../nerves/runtime");
 const context_1 = require("../mind/context");
+const prompt_budget_1 = require("../mind/prompt-budget");
 const prompt_1 = require("../mind/prompt");
 const kept_notes_1 = require("./kept-notes");
 const error_classification_1 = require("./providers/error-classification");
@@ -964,6 +965,16 @@ async function runAgent(messages, callbacks, channel, signal, options) {
                 callbacks.onModelStart();
                 habitCallbackBufferRef.current = habitSession ? createHabitCallbackBuffer(callbacks) : null;
                 try {
+                    const promptBudget = (0, prompt_budget_1.applyPromptBudget)({
+                        messages,
+                        provider: providerRuntime.id,
+                        model: providerRuntime.model,
+                        contextWindowTokens: (0, config_1.getContextConfig)().maxTokens,
+                    });
+                    if (promptBudget.status !== "within_budget") {
+                        messages.splice(0, messages.length, ...promptBudget.messages);
+                        providerRuntime.resetTurnState(messages);
+                    }
                     return await providerRuntime.streamTurn({
                         messages,
                         activeTools,

package/dist/heart/daemon/cadence.js

@@ -3,8 +3,55 @@ 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.
@@ -68,3 +115,66 @@ function parseCadenceToMs(raw) {
         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,
+    };
+}