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

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

@@ -68,6 +68,7 @@ const context_loss_sentinel_1 = require("../context-loss-sentinel");
 const provider_credentials_1 = require("../provider-credentials");
 const runtime_credentials_1 = require("../runtime-credentials");
 const machine_identity_1 = require("../machine-identity");
+const auth_flow_1 = require("../auth/auth-flow");
 function parseSocketPath(argv) {
     const socketIndex = argv.indexOf("--socket");
     if (socketIndex >= 0) {
@@ -483,16 +484,116 @@ function writeStopCommandHealthState() {
         // Health writes are best-effort during shutdown.
     }
 }
+function providerPreloadTargets(agent) {
+    try {
+        const { config } = (0, auth_flow_1.readAgentConfigForAgent)(agent, (0, identity_1.getAgentBundlesRoot)());
+        return [...new Set([config.humanFacing.provider, config.agentFacing.provider])];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.provider_preload_skipped",
+            message: "skipping provider credential preload because agent config could not be read",
+            meta: {
+                agent,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error config-read failures @preserve */ String(error),
+            },
+        });
+        return [];
+    }
+}
+function providerPreloadMissingTargets(result, providers) {
+    return providers.filter((provider) => !result.pool.providers[provider]);
+}
 async function preloadProviderCredentialPools() {
-    await Promise.all(managedAgents.map((agent) => (0, provider_credentials_1.refreshProviderCredentialPool)(agent, { preserveCachedOnFailure: true })));
+    await Promise.all(managedAgents.map(async (agent) => {
+        const providers = providerPreloadTargets(agent);
+        if (providers.length === 0)
+            return;
+        const result = await (0, provider_credentials_1.refreshProviderCredentialPool)(agent, { preserveCachedOnFailure: true, providers, skipCache: true });
+        if (result.ok) {
+            const missingProviders = providerPreloadMissingTargets(result, providers);
+            if (missingProviders.length > 0) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.provider_preload_unavailable",
+                    message: "provider credential preload returned an incomplete selected provider cache",
+                    meta: {
+                        agent,
+                        reason: "missing",
+                        error: `missing selected providers: ${missingProviders.join(", ")}`,
+                    },
+                });
+                return;
+            }
+            const records = Object.values(result.pool.providers).filter((record) => !!record);
+            (0, provider_credentials_1.cacheProviderCredentialRecords)(agent, records, new Date(result.pool.updatedAt));
+            return;
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.provider_preload_unavailable",
+            message: "provider credential preload could not refresh selected provider cache",
+            meta: {
+                agent,
+                reason: result.reason,
+                error: result.error,
+            },
+        });
+    }));
+}
+function startProviderCredentialPoolPreload() {
+    return preloadProviderCredentialPools().catch((error) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.provider_preload_error",
+            message: "provider credential preload failed after daemon startup",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive non-Error provider preload failures @preserve */ String(error) },
+        });
+    });
+}
+function scheduleStartupSentinelAfterProviderPreload(agent, preload) {
+    void preload.then(async () => {
+        const result = await refreshDaemonSentinel(agent, "daemon_startup");
+        if (result.status === "critical") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.startup_sentinel_error",
+                message: "startup Sentinel refresh reported critical after provider preload",
+                meta: {
+                    agent,
+                    error: result.message,
+                },
+            });
+        }
+        /* v8 ignore start -- refreshDaemonSentinel handles ordinary Sentinel failures; this is a promise-chain guard. @preserve */
+    }).catch((error) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.startup_sentinel_error",
+            message: "startup Sentinel refresh failed after provider preload",
+            meta: {
+                agent,
+                error: error instanceof Error ? error.message : String(error),
+            },
+        });
+    });
+    /* v8 ignore stop */
 }
 /* v8 ignore start -- habit wiring: lambdas delegate to processManager/fs; tested via HabitScheduler unit tests @preserve */
-void preloadProviderCredentialPools().then(() => daemon.start()).then(async () => {
+void daemon.start().then(async () => {
+    const providerPreload = startProviderCredentialPoolPreload();
     const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
     const ouroPath = (0, os_cron_deps_1.resolveOuroBinaryPath)();
     const osCronDeps = (0, os_cron_deps_1.createRealOsCronDeps)();
     for (const agent of managedAgents) {
-        await refreshDaemonSentinel(agent, "daemon_startup");
+        scheduleStartupSentinelAfterProviderPreload(agent, providerPreload);
         const bundleRoot = path.join(bundlesRoot, `${agent}.ouro`);
         const habitsDir = path.join(bundleRoot, "habits");
         const degradedComponent = `habits:${agent}`;

package/dist/heart/daemon/daemon.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OuroDaemon = void 0;
+exports.messageFromHabitPokeError = messageFromHabitPokeError;
 exports.parseOrphanPidsFromPs = parseOrphanPidsFromPs;
 exports.filterPidfilePidsToActualOrphans = filterPidfilePidsToActualOrphans;
 exports.mergeUniqueOrphanPids = mergeUniqueOrphanPids;
@@ -74,6 +75,7 @@ const habit_private_wake_1 = require("./habit-private-wake");
 const habit_parser_1 = require("../habits/habit-parser");
 const habit_runtime_state_1 = require("../habits/habit-runtime-state");
 const router_1 = require("../external-events/router");
+const habit_policy_1 = require("../../rsvp/habit-policy");
 const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
  * Defense-in-depth: detect if we're running under vitest. The pidfile lives
@@ -95,6 +97,12 @@ function isVitestProcess() {
         return false;
     return process.argv.some((arg) => typeof arg === "string" && arg.includes("vitest"));
 }
+function messageFromHabitPokeError(error) {
+    if (error instanceof Error)
+        return error.message;
+    /* v8 ignore next -- defensive fallback for hostile/non-Error throws from filesystem or parsers @preserve */
+    return String(error);
+}
 /**
  * Scan `ps -eo pid,ppid,command` output for daemon-owned entry points whose
  * parent has died (PPID reparented to init/PID 1). Returns the list of PIDs
@@ -1180,13 +1188,26 @@ class OuroDaemon {
         };
     }
     resolveHabitPokeOccurrenceId(command, trigger) {
-        if (trigger === "poke" || trigger === "manual")
-            return undefined;
         const agentRoot = path.join(this.bundlesRoot, `${command.agent}.ouro`);
         const habitPath = path.join(agentRoot, "habits", `${command.habitName}.md`);
+        let parsedHabit = null;
+        if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+            if (!fs.existsSync(habitPath))
+                return { skipReason: "RSVP habit file not found" };
+            try {
+                parsedHabit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+            }
+            catch (error) {
+                return { skipReason: `RSVP habit metadata invalid: ${messageFromHabitPokeError(error)}` };
+            }
+            if (!parsedHabit.rsvp)
+                return { skipReason: "RSVP habit metadata is required before private runtime wake" };
+        }
+        if (trigger === "poke" || trigger === "manual")
+            return undefined;
         if (!fs.existsSync(habitPath))
             return { skipReason: "habit file not found" };
-        const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+        const habit = parsedHabit ?? (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
         if (habit.cadence === null)
             return { skipReason: "habit has no cadence" };
         const cadence = habit.cadence;

package/dist/heart/daemon/doctor.js

@@ -13,6 +13,7 @@ exports.checkDaemon = checkDaemon;
 exports.checkAgents = checkAgents;
 exports.checkSenses = checkSenses;
 exports.checkHabits = checkHabits;
+exports.checkRsvp = checkRsvp;
 exports.checkSecurity = checkSecurity;
 exports.checkTrips = checkTrips;
 exports.checkMailroom = checkMailroom;
@@ -28,6 +29,9 @@ const machine_identity_1 = require("../machine-identity");
 const habit_parser_1 = require("../habits/habit-parser");
 const cadence_1 = require("./cadence");
 const nerves_1 = require("../../nerves");
+const config_1 = require("../../rsvp/config");
+const cutover_1 = require("../../rsvp/cutover");
+const diagnostics_1 = require("../../rsvp/diagnostics");
 const DEFAULT_BLUEBUBBLES_REQUEST_TIMEOUT_MS = 30_000;
 // ── Category checkers ──
 function checkCliPath(deps) {
@@ -397,6 +401,152 @@ function checkHabits(deps) {
     }
     return { name: "Habits", checks };
 }
+function hasRsvpHabitSignal(deps, agentPath) {
+    const habitsDir = `${agentPath}/habits`;
+    if (!deps.existsSync(habitsDir))
+        return false;
+    try {
+        return deps.readdirSync(habitsDir).some((name) => name.toLowerCase().includes("rsvp") && name.endsWith(".md"));
+    }
+    catch {
+        return false;
+    }
+}
+function rsvpDoctorLabel(agentDir, checkId) {
+    const suffix = {
+        "rsvp.native_config": "RSVP native config",
+        "rsvp.aisleplanner_source": "RSVP AislePlanner source",
+        "rsvp.aisleplanner_credentials": "RSVP AislePlanner credentials",
+        "rsvp.bluebubbles_route": "RSVP BlueBubbles route",
+        "rsvp.bluebubbles_attachment": "RSVP BlueBubbles attachment",
+    };
+    return `${agentDir} ${suffix[checkId]}`;
+}
+function rsvpDoctorId(checkId) {
+    const ids = {
+        "rsvp.native_config": "rsvp.native_config",
+        "rsvp.aisleplanner_source": "rsvp.aisleplanner.source",
+        "rsvp.aisleplanner_credentials": "rsvp.aisleplanner.credentials",
+        "rsvp.bluebubbles_route": "rsvp.bluebubbles.route",
+        "rsvp.bluebubbles_attachment": "rsvp.bluebubbles.attachment",
+    };
+    return ids[checkId];
+}
+function rsvpDoctorDetail(readinessCheck) {
+    return readinessCheck.id === "rsvp.bluebubbles_route" && readinessCheck.status === "pass"
+        ? "configured"
+        : readinessCheck.detail;
+}
+function doctorStatus(status) {
+    return status;
+}
+function discoverRsvpCutoverLegacyRoot(deps, config) {
+    const configured = typeof config?.cutover?.legacyRoot === "string" ? config.cutover.legacyRoot.trim() : "";
+    if (configured)
+        return configured;
+    if (deps.rsvpCutoverLegacyRoot)
+        return deps.rsvpCutoverLegacyRoot;
+    const candidate = `${deps.homedir}/Projects/rsvp-tracker`;
+    return deps.existsSync(`${candidate}/config.json`) ? candidate : null;
+}
+function rsvpCutoverDetail(checks, sendAllowed, denialCount) {
+    return [
+        `sendAllowed=${sendAllowed}`,
+        `launchAgentInactive=${checks.launchAgentInactive}`,
+        `legacyProcessInactive=${checks.legacyProcessInactive}`,
+        `legacyConfigSendInactive=${checks.legacyConfigSendInactive}`,
+        `legacyLiveSendInactive=${checks.legacyLiveSendInactive}`,
+        `nativeBlueBubblesCredentialHealthy=${checks.nativeBlueBubblesCredentialHealthy}`,
+        `denialCount=${denialCount}`,
+    ].join("; ");
+}
+async function checkRsvp(deps) {
+    const checks = [];
+    const agents = discoverAgents(deps);
+    if (agents.length === 0) {
+        checks.push({ label: "RSVP", status: "warn", detail: "no agent bundles found" });
+        return { name: "RSVP", checks };
+    }
+    for (const agentDir of agents) {
+        const agentName = agentDir.replace(/\.ouro$/, "");
+        const agentPath = `${deps.bundlesRoot}/${agentDir}`;
+        const config = (0, config_1.readRsvpConfig)(agentPath);
+        const hasRsvpSignal = config.ok || hasRsvpHabitSignal(deps, agentPath);
+        if (!hasRsvpSignal) {
+            checks.push({ label: `${agentDir} RSVP`, status: "pass", detail: "not configured" });
+            continue;
+        }
+        const machineId = (0, machine_identity_1.loadOrCreateMachineIdentity)({ homeDir: deps.homedir }).machineId;
+        const runtimeConfig = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agentName, { preserveCachedOnFailure: true });
+        const machineRuntimeConfig = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agentName, machineId, { preserveCachedOnFailure: true });
+        const readiness = (0, config_1.validateRsvpReadiness)({
+            agent: agentName,
+            agentRoot: agentPath,
+            runtimeConfig,
+            machineRuntimeConfig,
+            config,
+        });
+        for (const readinessCheck of readiness.checks) {
+            checks.push({
+                id: rsvpDoctorId(readinessCheck.id),
+                label: rsvpDoctorLabel(agentDir, readinessCheck.id),
+                status: readinessCheck.status === "pass" ? "pass" : "fail",
+                detail: rsvpDoctorDetail(readinessCheck),
+            });
+        }
+        const attachment = readiness.checks.find((check) => check.id === "rsvp.bluebubbles_attachment");
+        if (attachment) {
+            checks.push({
+                id: "rsvp.bluebubbles.attachment_identity",
+                label: `${agentDir} RSVP BlueBubbles attachment identity`,
+                status: attachment.status === "pass" ? "pass" : "fail",
+                detail: attachment.status === "pass" ? "machine attachment credential present" : attachment.detail,
+            });
+        }
+        const diagnostics = (0, diagnostics_1.collectRsvpDiagnostics)(agentPath, deps);
+        checks.push({
+            id: "rsvp.context_packet_ledger",
+            label: `${agentDir} RSVP context packet ledger`,
+            status: doctorStatus(diagnostics.contextPacketLedger.status),
+            detail: diagnostics.contextPacketLedger.detail,
+        }, {
+            id: "rsvp.habit.schedule",
+            label: `${agentDir} RSVP habit schedule`,
+            status: doctorStatus(diagnostics.habitSchedule.status),
+            detail: diagnostics.habitSchedule.detail,
+        }, {
+            id: "rsvp.latest_fetch",
+            label: `${agentDir} RSVP latest fetch`,
+            status: doctorStatus(diagnostics.latestFetch.status),
+            detail: diagnostics.latestFetch.detail,
+        }, {
+            id: "rsvp.delivery.reconciliation",
+            label: `${agentDir} RSVP delivery reconciliation`,
+            status: doctorStatus(diagnostics.deliveryReconciliation.status),
+            detail: diagnostics.deliveryReconciliation.detail,
+        }, {
+            id: "rsvp.spend_timeline",
+            label: `${agentDir} RSVP spend timeline`,
+            status: doctorStatus(diagnostics.spendTimeline.status),
+            detail: diagnostics.spendTimeline.detail,
+        });
+        const legacyRoot = discoverRsvpCutoverLegacyRoot(deps, config.ok ? config.config : undefined);
+        if (config.ok && legacyRoot) {
+            const cutover = await (0, cutover_1.checkRsvpCutover)({
+                agent: agentName,
+                legacyRoot,
+                ...(deps.rsvpCutoverDeps ? { deps: deps.rsvpCutoverDeps } : {}),
+            });
+            checks.push({
+                id: "rsvp.cutover.live_send_preflight",
+                label: `${agentDir} RSVP legacy live-send preflight`,
+                status: cutover.sendAllowed ? "pass" : "fail",
+                detail: rsvpCutoverDetail(cutover.checks, cutover.sendAllowed, cutover.denialReasons.length),
+            });
+        }
+    }
+    return { name: "RSVP", checks };
+}
 function checkSecurity(deps) {
     const checks = [];
     const agents = discoverAgents(deps);
@@ -934,6 +1084,7 @@ const CATEGORY_CHECKERS = [
     { name: "Agents", fn: checkAgents },
     { name: "Senses", fn: checkSenses },
     { name: "Habits", fn: checkHabits },
+    { name: "RSVP", fn: checkRsvp },
     { name: "Security", fn: checkSecurity },
     { name: "Trips", fn: checkTrips },
     { name: "Mailroom", fn: checkMailroom },

package/dist/heart/daemon/stale-bundle-prune.js

@@ -39,13 +39,16 @@ const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
 /**
- * Scan the bundles root for `.ouro` directories that have no `agent.json`
- * file (definitively dead ephemeral bundles) and delete them.
+ * Scan the bundles root for `.ouro` directories that have no bundle contract
+ * or durable state markers (definitively dead ephemeral bundles) and delete
+ * them.
  *
  * Returns a list of pruned bundle directory names (e.g. `["stale.ouro"]`)
  * for display purposes. Bundles that have `agent.json` -- even if disabled
- * -- are never deleted. Errors on individual bundles are swallowed so that
- * one permission-denied doesn't block pruning the rest.
+ * -- are never deleted. Task-doc-only bundles are also durable work state, so
+ * directories with state roots such as `tasks`, `desk`, `arc`, `state`, or
+ * `.git` are preserved. Errors on individual bundles are swallowed so that one
+ * permission-denied doesn't block pruning the rest.
  */
 function pruneStaleEphemeralBundles(deps = {}) {
     const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
@@ -64,8 +67,7 @@ function pruneStaleEphemeralBundles(deps = {}) {
         if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
             continue;
         const bundlePath = path.join(bundlesRoot, entry.name);
-        const agentJsonPath = path.join(bundlePath, "agent.json");
-        if (existsSync(agentJsonPath))
+        if (hasDurableBundleMarker(bundlePath, existsSync))
             continue;
         try {
             rmSync(bundlePath, { recursive: true, force: true });
@@ -94,3 +96,18 @@ function pruneStaleEphemeralBundles(deps = {}) {
     }
     return pruned;
 }
+const DURABLE_BUNDLE_MARKERS = [
+    "agent.json",
+    "tasks",
+    "desk",
+    "arc",
+    "state",
+    "habits",
+    "friends",
+    "facts",
+    "vault",
+    ".git",
+];
+function hasDurableBundleMarker(bundlePath, existsSync) {
+    return DURABLE_BUNDLE_MARKERS.some((marker) => existsSync(path.join(bundlePath, marker)));
+}

package/dist/heart/habits/habit-parser.js

@@ -38,6 +38,7 @@ exports.renderHabitFile = renderHabitFile;
 const path = __importStar(require("path"));
 const frontmatter_1 = require("../../util/frontmatter");
 const runtime_1 = require("../../nerves/runtime");
+const habit_policy_1 = require("../../rsvp/habit-policy");
 function isHabitStatus(value) {
     return value === "active" || value === "paused";
 }
@@ -157,7 +158,8 @@ function parseHabitFile(content, filePath) {
     const lastRun = typeof rawLastRun === "string" && rawLastRun.length > 0 ? rawLastRun : null;
     const rawCreated = frontmatter.created;
     const created = typeof rawCreated === "string" && rawCreated.length > 0 ? rawCreated : null;
-    const tools = parseToolsField(frontmatter.tools);
+    const rsvp = (0, habit_policy_1.parseRsvpHabitMetadata)(frontmatter.rsvp);
+    const tools = rsvp ? [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS] : parseToolsField(frontmatter.tools);
     const origin = parseOrigin(frontmatter.origin);
     const surface = parseSurface(frontmatter.surface);
     const continuity = parseContinuity(frontmatter.continuity);
@@ -169,6 +171,7 @@ function parseHabitFile(content, filePath) {
         lastRun,
         created,
         tools,
+        ...(rsvp ? { rsvp } : {}),
         origin,
         surface,
         continuity,

package/dist/heart/habits/habit-scheduler.js

@@ -39,6 +39,7 @@ const runtime_1 = require("../../nerves/runtime");
 const habit_parser_1 = require("./habit-parser");
 const habit_runtime_state_1 = require("./habit-runtime-state");
 const cadence_1 = require("../daemon/cadence");
+const habit_policy_1 = require("../../rsvp/habit-policy");
 const WATCH_DEBOUNCE_MS = 200;
 class HabitScheduler {
     agent;
@@ -97,33 +98,21 @@ class HabitScheduler {
                 continue;
             if (!habit.cadence)
                 continue;
-            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
-            if (cadenceMs === null)
+            if (this.rejectInvalidRsvpHabit(habit))
                 continue;
             const nowMs = this.deps.now();
-            if (habit.lastRun === null) {
-                (0, runtime_1.emitNervesEvent)({
-                    component: "daemon",
-                    event: "daemon.habit_fire",
-                    message: "firing overdue habit (never run)",
-                    meta: { habitName: habit.name, agent: this.agent },
-                });
-                this.onHabitFire(habit.name, "overdue", {
-                    occurrenceId: this.overdueOccurrenceId(habit),
-                });
+            const dueState = (0, cadence_1.evaluateCadenceDue)(habit.cadence, habit.lastRun, nowMs);
+            if (dueState === null)
                 continue;
-            }
-            const lastRunMs = new Date(habit.lastRun).getTime();
-            const elapsed = nowMs - lastRunMs;
-            if (elapsed >= cadenceMs) {
+            if (dueState.due) {
                 (0, runtime_1.emitNervesEvent)({
                     component: "daemon",
                     event: "daemon.habit_fire",
-                    message: "firing overdue habit",
-                    meta: { habitName: habit.name, agent: this.agent, elapsedMs: elapsed },
+                    message: habit.lastRun === null ? "firing overdue habit (never run)" : "firing overdue habit",
+                    meta: { habitName: habit.name, agent: this.agent, elapsedMs: dueState.elapsedMs },
                 });
                 this.onHabitFire(habit.name, "overdue", {
-                    occurrenceId: this.overdueOccurrenceId(habit),
+                    occurrenceId: dueState.occurrenceId ?? this.overdueOccurrenceId(habit),
                 });
             }
         }
@@ -150,18 +139,11 @@ class HabitScheduler {
                 continue;
             if (!habit.cadence)
                 continue;
-            const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
-            if (cadenceMs === null)
+            if (this.rejectInvalidRsvpHabit(habit))
                 continue;
-            if (habit.lastRun === null) {
-                overdue.push({ name: habit.name, elapsedMs: Infinity });
-                continue;
-            }
-            const lastRunMs = new Date(habit.lastRun).getTime();
-            const elapsed = nowMs - lastRunMs;
-            if (elapsed >= cadenceMs) {
-                overdue.push({ name: habit.name, elapsedMs: elapsed });
-            }
+            const dueState = (0, cadence_1.evaluateCadenceDue)(habit.cadence, habit.lastRun, nowMs);
+            if (dueState?.due)
+                overdue.push({ name: habit.name, elapsedMs: dueState.elapsedMs });
         }
         return overdue;
     }
@@ -278,9 +260,9 @@ class HabitScheduler {
                 });
                 // Parse cadence from the original habit file for timer interval
                 const habitFile = this.getHabitFile(job.taskId);
-                const ms = habitFile?.cadence ? (0, cadence_1.parseCadenceToMs)(habitFile.cadence) : null;
+                const ms = habitFile?.cadence ? (0, cadence_1.cadenceFallbackDelayMs)(habitFile.cadence, this.deps.now()) : null;
                 if (ms !== null) {
-                    this.createTimerFallback(job.taskId, ms);
+                    this.createTimerFallback(job.taskId, habitFile.cadence, ms);
                 }
                 this.degradedHabitNames.set(job.taskId, "cron registration failed — using timer fallback");
             }
@@ -315,14 +297,15 @@ class HabitScheduler {
         }
         return verified;
     }
-    createTimerFallback(habitName, cadenceMs) {
+    createTimerFallback(habitName, cadence, firstDelayMs) {
         const schedule = () => {
+            const delayMs = (0, cadence_1.cadenceFallbackDelayMs)(cadence, this.deps.now()) ?? firstDelayMs;
             const timer = setTimeout(() => {
                 this.onHabitFire(habitName, "overdue", {
-                    occurrenceId: this.timerOccurrenceId(habitName, cadenceMs),
+                    occurrenceId: this.timerOccurrenceId(habitName, cadence),
                 });
                 schedule();
-            }, cadenceMs);
+            }, delayMs);
             this.timerFallbacks.set(habitName, timer);
         };
         schedule();
@@ -380,6 +363,8 @@ class HabitScheduler {
                 continue;
             if (!habit.cadence)
                 continue;
+            if (this.rejectInvalidRsvpHabit(habit))
+                continue;
             const cronSchedule = (0, cadence_1.parseCadenceToCron)(habit.cadence);
             if (cronSchedule === null)
                 continue;
@@ -395,6 +380,24 @@ class HabitScheduler {
         }
         return jobs;
     }
+    rejectInvalidRsvpHabit(habit) {
+        if (!(0, habit_policy_1.isRsvpHabitName)(habit.name) || habit.rsvp)
+            return false;
+        this.recordHabitParseError(`${habit.name}.md`, "RSVP habit metadata is required before scheduling");
+        return true;
+    }
+    recordHabitParseError(file, error) {
+        if (this.parseErrors.some((existing) => existing.file === file && existing.error === error))
+            return;
+        this.parseErrors.push({ file, error });
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.habit_parse_error",
+            message: "failed to parse habit file",
+            meta: { file, error, agent: this.agent },
+        });
+    }
     overdueOccurrenceId(habit) {
         if (habit.lastRun === null)
             return `overdue:first-run:${habit.cadence}`;
@@ -403,9 +406,14 @@ class HabitScheduler {
     jobOccurrenceId(job, trigger) {
         return `job:${job.id}:${trigger}:last-run:${job.lastRun ?? "never"}`;
     }
-    timerOccurrenceId(habitName, cadenceMs) {
-        const slot = Math.floor(this.deps.now() / cadenceMs);
-        return `timer:${habitName}:cadence-ms:${cadenceMs}:slot:${slot}`;
+    timerOccurrenceId(habitName, cadence) {
+        const cadenceMs = (0, cadence_1.parseCadenceToMs)(cadence);
+        if (cadenceMs !== null) {
+            const slot = Math.floor(this.deps.now() / cadenceMs);
+            return `timer:${habitName}:cadence-ms:${cadenceMs}:slot:${slot}`;
+        }
+        const slot = (0, cadence_1.nextCadenceRunAt)(cadence, this.deps.now()) ?? "unknown";
+        return `timer:${habitName}:cadence:${cadence}:slot:${slot}`;
     }
 }
 exports.HabitScheduler = HabitScheduler;

package/dist/heart/habits/habit-session.js

@@ -453,11 +453,10 @@ function filterHabitToolsForEnvelope(definitions, requestedTools, envelope, risk
 function computeNextRunAt(habit, endedAt) {
     if (habit.status !== "active" || !habit.cadence)
         return null;
-    const cadenceMs = (0, cadence_1.parseCadenceToMs)(habit.cadence);
     const endedMs = Date.parse(endedAt);
-    if (cadenceMs === null || !Number.isFinite(endedMs))
+    if (!Number.isFinite(endedMs))
         return null;
-    return new Date(endedMs + cadenceMs).toISOString();
+    return (0, cadence_1.nextCadenceRunAt)(habit.cadence, endedMs);
 }
 function defaultSummarySnapshot(input) {
     const errors = input.errors ?? [];

package/dist/heart/provider-credentials.js

@@ -241,6 +241,7 @@ function readProviderCredentialPool(agentName) {
 }
 async function refreshProviderCredentialPool(agentName, options = {}) {
     const providersToRead = selectedProviders(options.providers);
+    const requiresAllSelectedProviders = !!options.providers && options.providers.length > 0;
     try {
         const store = (0, credential_access_1.getCredentialStore)(agentName);
         options.onProgress?.(`reading vault items for ${agentName}...`);
@@ -266,6 +267,21 @@ async function refreshProviderCredentialPool(agentName, options = {}) {
                 updatedAt = record.updatedAt;
         }
         options.onProgress?.("parsing provider credentials...");
+        const missingRequestedProviders = requiresAllSelectedProviders
+            ? providersToRead.filter((provider) => !providers[provider])
+            : [];
+        if (missingRequestedProviders.length > 0) {
+            const cached = cachedPools.get(agentName);
+            const result = {
+                ok: false,
+                reason: "missing",
+                poolPath: providerCredentialsVaultPath(agentName),
+                error: `requested provider credentials missing from ${providerCredentialsVaultPath(agentName)}: ${missingRequestedProviders.join(", ")}`,
+            };
+            if (options.preserveCachedOnFailure && cached?.ok)
+                return cached;
+            return options.skipCache ? result : cacheResult(agentName, result);
+        }
         const pool = {
             schemaVersion: 1,
             updatedAt,