@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

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

@@ -0,0 +1,653 @@
+"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.HabitScheduler = void 0;
+const path = __importStar(require("path"));
+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;
+const MAX_CRON_VERIFICATION_ATTEMPTS = 3;
+class HabitScheduler {
+    agent;
+    habitsDir;
+    osCronManager;
+    onHabitFire;
+    deps;
+    execForVerify;
+    verifyJobs;
+    platform;
+    watcher = null;
+    debounceTimer = null;
+    parseErrors = [];
+    timerFallbacks = new Map();
+    timerFallbackGenerations = new Map();
+    degradedHabitNames = new Map();
+    periodicTimer = null;
+    habitSnapshots = new Map();
+    constructor(options) {
+        this.agent = options.agent;
+        this.habitsDir = options.habitsDir;
+        this.osCronManager = options.osCronManager;
+        this.onHabitFire = options.onHabitFire;
+        this.deps = options.deps;
+        this.execForVerify = options.execForVerify;
+        this.verifyJobs = options.verifyJobs;
+        this.platform = options.platform ?? process.platform;
+    }
+    start() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_start",
+            message: "habit scheduler starting",
+            meta: { agent: this.agent, habitsDir: this.habitsDir },
+        });
+        this.runSchedulingCycle();
+    }
+    reconcile() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_reconcile",
+            message: "habit scheduler reconciling",
+            meta: { agent: this.agent },
+        });
+        // Clear ALL existing timers FIRST to prevent overlap window
+        this.clearAllTimerFallbacks();
+        this.runSchedulingCycle();
+    }
+    runSchedulingCycle() {
+        const scannedHabits = this.scanHabits();
+        let state = this.revalidateState({
+            habits: scannedHabits,
+            jobs: this.buildJobs(scannedHabits),
+        });
+        if (!this.syncJobsFailClosed(state.jobs))
+            return;
+        const afterSync = this.revalidateAndCorrectJobs(state);
+        if (afterSync === null)
+            return;
+        state = afterSync;
+        const afterVerification = this.verifyCronAndCreateFallbacks(state);
+        if (afterVerification === null)
+            return;
+        state = afterVerification;
+        const beforeDispatch = this.revalidateAndCorrectJobs(state);
+        if (beforeDispatch === null)
+            return;
+        this.fireOverdueHabits(beforeDispatch);
+    }
+    fireOverdueHabits(state) {
+        for (const expectedJob of state.jobs) {
+            const habit = this.revalidateHabit(expectedJob.taskId);
+            if (habit === null)
+                continue;
+            const currentJob = this.buildJobs([habit]).find((job) => job.id === expectedJob.id);
+            if (!currentJob || !this.jobEqual(expectedJob, currentJob))
+                continue;
+            const nowMs = this.deps.now();
+            const dueState = (0, cadence_1.evaluateCadenceDue)(habit.cadence, habit.lastRun, nowMs);
+            if (dueState === null)
+                continue;
+            if (dueState.due) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "daemon",
+                    event: "daemon.habit_fire",
+                    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: dueState.occurrenceId ?? this.overdueOccurrenceId(habit),
+                });
+            }
+        }
+    }
+    stop() {
+        // `_end` (not `_stop`) to pair with `daemon.habit_scheduler_start`
+        // under the nerves audit start/end pairing rule.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_scheduler_end",
+            message: "habit scheduler stopping",
+            meta: { agent: this.agent },
+        });
+        this.stopPeriodicReconciliation();
+        this.clearAllTimerFallbacks();
+        this.osCronManager.removeAll();
+    }
+    listOverdueHabits() {
+        const habits = this.scanHabits();
+        const nowMs = this.deps.now();
+        const overdue = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            if (this.rejectInvalidRsvpHabit(habit))
+                continue;
+            if (this.rejectReservedCronNamespaceHabit(habit))
+                continue;
+            const dueState = (0, cadence_1.evaluateCadenceDue)(habit.cadence, habit.lastRun, nowMs);
+            if (dueState?.due)
+                overdue.push({ name: habit.name, elapsedMs: dueState.elapsedMs });
+        }
+        return overdue;
+    }
+    getParseErrors() {
+        return [...this.parseErrors];
+    }
+    getHabitFile(name) {
+        const filePath = path.join(this.habitsDir, `${name}.md`);
+        try {
+            const content = this.deps.readFile(filePath, "utf-8");
+            return (0, habit_runtime_state_1.applyHabitRuntimeState)(path.dirname(this.habitsDir), (0, habit_parser_1.parseHabitFile)(content, filePath));
+        }
+        catch {
+            return null;
+        }
+    }
+    listJobs() {
+        return this.buildJobs(this.scanHabits())
+            .map((job) => ({ id: job.id, schedule: job.schedule, lastRun: job.lastRun }))
+            .sort((a, b) => a.id.localeCompare(b.id));
+    }
+    async triggerJob(jobId, trigger = "cron") {
+        const job = this.buildJobs(this.scanHabits()).find((candidate) => candidate.id === jobId);
+        if (!job) {
+            return { ok: false, message: `unknown habit job: ${jobId}` };
+        }
+        const currentHabit = this.revalidateHabit(job.taskId);
+        const currentJob = currentHabit === null
+            ? undefined
+            : this.buildJobs([currentHabit]).find((candidate) => candidate.id === jobId);
+        if (!currentJob) {
+            return { ok: false, message: `unknown habit job: ${jobId}` };
+        }
+        this.onHabitFire(currentJob.taskId, trigger, {
+            occurrenceId: this.jobOccurrenceId(currentJob, trigger),
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.habit_job_triggered",
+            message: "habit scheduler job triggered",
+            meta: { agent: currentJob.agent, habitName: currentJob.taskId, jobId, trigger },
+        });
+        return { ok: true, message: `triggered habit ${jobId}` };
+    }
+    watchForChanges() {
+        const watchFn = this.deps.watch;
+        if (!watchFn)
+            return;
+        // Ensure habits directory exists before watching — agents may not have one yet
+        try {
+            this.watcher = watchFn(this.habitsDir, (_event, _filename) => {
+                if (this.debounceTimer !== null) {
+                    clearTimeout(this.debounceTimer);
+                }
+                this.debounceTimer = setTimeout(() => {
+                    this.debounceTimer = null;
+                    this.reconcile();
+                }, WATCH_DEBOUNCE_MS);
+            });
+            /* v8 ignore start — ENOENT catch requires real missing directory @preserve */
+        }
+        catch {
+            // habits directory may not exist for all agents — skip watching silently
+        }
+        /* v8 ignore stop */
+    }
+    stopWatching() {
+        if (this.debounceTimer !== null) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher !== null) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    getDegradedHabits() {
+        const result = [];
+        for (const [name, reason] of this.degradedHabitNames) {
+            result.push({ name, reason });
+        }
+        return result;
+    }
+    static DEFAULT_PERIODIC_INTERVAL_MS = 300_000; // 5 minutes
+    static INITIAL_RECONCILIATION_DELAY_MS = 30_000; // 30 seconds
+    startPeriodicReconciliation(intervalMs) {
+        const interval = intervalMs ?? HabitScheduler.DEFAULT_PERIODIC_INTERVAL_MS;
+        // First reconciliation after a short delay (30s)
+        this.periodicTimer = setTimeout(() => {
+            this.reconcile();
+            this.scheduleNextReconciliation(interval);
+        }, HabitScheduler.INITIAL_RECONCILIATION_DELAY_MS);
+    }
+    stopPeriodicReconciliation() {
+        if (this.periodicTimer !== null) {
+            clearTimeout(this.periodicTimer);
+            this.periodicTimer = null;
+        }
+    }
+    scheduleNextReconciliation(intervalMs) {
+        this.periodicTimer = setTimeout(() => {
+            this.reconcile();
+            this.scheduleNextReconciliation(intervalMs);
+        }, intervalMs);
+    }
+    verifyCronAndCreateFallbacks(state) {
+        if ((!this.execForVerify && !this.verifyJobs) || state.jobs.length === 0)
+            return state;
+        let currentState = state;
+        for (let attempt = 1; attempt <= MAX_CRON_VERIFICATION_ATTEMPTS; attempt += 1) {
+            const verifiedLabels = this.verifyJobs?.(currentState.jobs)
+                ? new Set(currentState.jobs.map((job) => this.platform === "darwin" ? `bot.ouro.${job.agent}.${job.taskId}` : job.taskId))
+                : this.execForVerify ? this.verifyCronEntries() : new Set();
+            const revalidatedState = this.revalidateAndCorrectJobs(currentState);
+            if (revalidatedState === null)
+                return null;
+            if (!this.jobsEqual(currentState.jobs, revalidatedState.jobs)) {
+                currentState = revalidatedState;
+                if (currentState.jobs.length === 0)
+                    return currentState;
+                continue;
+            }
+            currentState = revalidatedState;
+            for (const job of currentState.jobs) {
+                const label = `bot.ouro.${job.agent}.${job.taskId}`;
+                const isVerified = this.platform === "darwin"
+                    ? verifiedLabels.has(label)
+                    : verifiedLabels.has(job.taskId);
+                if (!isVerified) {
+                    (0, runtime_1.emitNervesEvent)({
+                        component: "daemon",
+                        event: "daemon.habit_cron_verification_failed",
+                        message: `cron verification failed for habit: ${job.taskId}`,
+                        meta: { habitName: job.taskId, agent: job.agent, label },
+                    });
+                    const habitFile = currentState.habits.find((habit) => habit.name === job.taskId);
+                    const cadence = habitFile.cadence;
+                    const ms = (0, cadence_1.cadenceFallbackDelayMs)(cadence, this.deps.now());
+                    if (ms !== null) {
+                        this.createTimerFallback(job.taskId, cadence, ms);
+                        this.degradedHabitNames.set(job.taskId, "cron registration failed — using timer fallback");
+                    }
+                    else {
+                        this.degradedHabitNames.set(job.taskId, "cron registration failed — no timer fallback available");
+                    }
+                }
+            }
+            return currentState;
+        }
+        this.clearAllTimerFallbacks();
+        let cleanupError = null;
+        try {
+            this.osCronManager.removeAll();
+        }
+        catch (error) {
+            cleanupError = this.errorMessage(error);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.habit_cron_verification_unstable",
+            message: "habit scheduler cron verification did not stabilize; fail-closed cleanup attempted",
+            meta: {
+                agent: this.agent,
+                attempts: MAX_CRON_VERIFICATION_ATTEMPTS,
+                jobCount: currentState.jobs.length,
+                cleanupError,
+            },
+        });
+        return null;
+    }
+    verifyCronEntries() {
+        const verified = new Set();
+        try {
+            if (this.platform === "darwin") {
+                const output = this.execForVerify("launchctl list");
+                const lines = output.split("\n");
+                for (const line of lines) {
+                    const match = line.match(/bot\.ouro\.\S+\.\S+/);
+                    if (match) {
+                        verified.add(match[0]);
+                    }
+                }
+            }
+            else {
+                const output = this.execForVerify("crontab -l");
+                const lines = output.split("\n");
+                for (const line of lines) {
+                    const match = line.match(/ouro poke \S+ --habit (\S+)(?:\s+--trigger\s+\S+)?/);
+                    if (match) {
+                        verified.add(match[1]);
+                    }
+                }
+            }
+        }
+        catch {
+            // Verification command failed — return empty set (all habits unverified)
+        }
+        return verified;
+    }
+    createTimerFallback(habitName, cadence, firstDelayMs) {
+        if (this.timerFallbacks.has(habitName))
+            this.clearTimerFallback(habitName);
+        const generation = this.nextTimerFallbackGeneration(habitName);
+        const schedule = () => {
+            const delayMs = (0, cadence_1.cadenceFallbackDelayMs)(cadence, this.deps.now()) ?? firstDelayMs;
+            const timer = setTimeout(() => {
+                const owner = this.timerFallbacks.get(habitName);
+                if (!owner || owner.handle !== timer || owner.generation !== generation)
+                    return;
+                const currentHabit = this.revalidateHabit(habitName);
+                const currentJob = currentHabit === null
+                    ? undefined
+                    : this.buildJobs([currentHabit]).find((job) => job.taskId === habitName);
+                if (!currentJob || currentHabit?.cadence !== cadence) {
+                    this.clearTimerFallback(habitName);
+                    return;
+                }
+                this.onHabitFire(habitName, "overdue", {
+                    occurrenceId: this.timerOccurrenceId(habitName, cadence),
+                });
+                const currentOwner = this.timerFallbacks.get(habitName);
+                if (!currentOwner || currentOwner.handle !== timer || currentOwner.generation !== generation)
+                    return;
+                schedule();
+            }, delayMs);
+            this.timerFallbacks.set(habitName, { handle: timer, cadence, generation });
+        };
+        schedule();
+    }
+    clearAllTimerFallbacks() {
+        for (const name of [...this.timerFallbacks.keys()])
+            this.clearTimerFallback(name);
+        this.degradedHabitNames.clear();
+    }
+    clearTimerFallback(name) {
+        const owner = this.timerFallbacks.get(name);
+        clearTimeout(owner.handle);
+        this.timerFallbacks.delete(name);
+        this.degradedHabitNames.delete(name);
+        this.nextTimerFallbackGeneration(name);
+    }
+    nextTimerFallbackGeneration(name) {
+        const generation = (this.timerFallbackGenerations.get(name) ?? 0) + 1;
+        this.timerFallbackGenerations.set(name, generation);
+        return generation;
+    }
+    revalidateState(state) {
+        const habits = [];
+        for (const habit of state.habits) {
+            const currentHabit = this.revalidateHabit(habit.name);
+            if (currentHabit !== null)
+                habits.push(currentHabit);
+        }
+        return { habits, jobs: this.buildJobs(habits) };
+    }
+    revalidateAndCorrectJobs(state) {
+        const currentState = this.revalidateState(state);
+        this.pruneTimerFallbacks(state, currentState);
+        if (this.jobsEqual(state.jobs, currentState.jobs))
+            return currentState;
+        return this.syncJobsFailClosed(currentState.jobs) ? currentState : null;
+    }
+    revalidateHabit(name) {
+        const file = `${name}.md`;
+        const filePath = path.join(this.habitsDir, file);
+        let content;
+        try {
+            content = this.deps.readFile(filePath, "utf-8");
+        }
+        catch (error) {
+            this.habitSnapshots.delete(name);
+            this.recordHabitParseError(file, `habit definition unreadable during scheduler revalidation: ${this.errorMessage(error)}`);
+            return null;
+        }
+        try {
+            const cached = this.habitSnapshots.get(name);
+            const definition = cached?.content === content
+                ? cached.definition
+                : (0, habit_parser_1.parseHabitFile)(content, filePath);
+            this.habitSnapshots.set(name, { content, definition });
+            const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(path.dirname(this.habitsDir), definition);
+            this.recordDegradedHabitError(file, habit);
+            return habit;
+        }
+        catch (error) {
+            this.habitSnapshots.delete(name);
+            this.recordHabitParseError(file, this.errorMessage(error));
+            return null;
+        }
+    }
+    syncJobsFailClosed(jobs) {
+        try {
+            this.osCronManager.sync(jobs);
+            return true;
+        }
+        catch (error) {
+            this.clearAllTimerFallbacks();
+            let cleanupError = null;
+            try {
+                this.osCronManager.removeAll();
+            }
+            catch (cleanupFailure) {
+                cleanupError = this.errorMessage(cleanupFailure);
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.habit_scheduler_sync_error",
+                message: "habit scheduler cron synchronization failed; fail-closed cleanup attempted",
+                meta: {
+                    agent: this.agent,
+                    error: this.errorMessage(error),
+                    cleanupError,
+                    jobCount: jobs.length,
+                },
+            });
+            return false;
+        }
+    }
+    pruneTimerFallbacks(previousState, currentState) {
+        for (const [name, owner] of this.timerFallbacks) {
+            const previousJob = previousState.jobs.find((job) => job.taskId === name);
+            const currentJob = currentState.jobs.find((job) => job.taskId === name);
+            const currentHabit = currentState.habits.find((habit) => habit.name === name);
+            if (previousJob
+                && currentJob
+                && currentHabit?.cadence === owner.cadence
+                && this.jobEqual(previousJob, currentJob))
+                continue;
+            this.clearTimerFallback(name);
+        }
+    }
+    jobsEqual(left, right) {
+        if (left.length !== right.length)
+            return false;
+        return left.every((job, index) => this.jobEqual(job, right[index]));
+    }
+    jobEqual(left, right) {
+        return right !== undefined
+            && left.id === right.id
+            && left.agent === right.agent
+            && left.taskId === right.taskId
+            && left.schedule === right.schedule
+            && left.lastRun === right.lastRun
+            && left.command === right.command
+            && left.taskPath === right.taskPath;
+    }
+    errorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    scanHabits() {
+        let files;
+        try {
+            files = this.deps.readdir(this.habitsDir);
+        }
+        catch {
+            this.parseErrors = [];
+            this.habitSnapshots.clear();
+            return [];
+        }
+        const habits = [];
+        const errors = [];
+        const snapshots = new Map();
+        for (const file of files) {
+            if (!file.endsWith(".md"))
+                continue;
+            const filePath = path.join(this.habitsDir, file);
+            try {
+                const content = this.deps.readFile(filePath, "utf-8");
+                const definition = (0, habit_parser_1.parseHabitFile)(content, filePath);
+                const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(path.dirname(this.habitsDir), definition);
+                snapshots.set(habit.name, { content, definition });
+                habits.push(habit);
+                if (habit.status === "degraded") {
+                    const error = `habit definition degraded: ${habit.degradedReason}`;
+                    errors.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 },
+                    });
+                }
+            }
+            catch (error) {
+                const errorMessage = this.errorMessage(error);
+                errors.push({ file, error: errorMessage });
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.habit_parse_error",
+                    message: "failed to parse habit file",
+                    meta: {
+                        file,
+                        error: errorMessage,
+                        agent: this.agent,
+                    },
+                });
+            }
+        }
+        this.parseErrors = errors;
+        this.habitSnapshots = snapshots;
+        return habits;
+    }
+    buildJobs(habits) {
+        const jobs = [];
+        for (const habit of habits) {
+            if (habit.status !== "active")
+                continue;
+            if (!habit.cadence)
+                continue;
+            if (this.rejectInvalidRsvpHabit(habit))
+                continue;
+            if (this.rejectReservedCronNamespaceHabit(habit))
+                continue;
+            const cronSchedule = (0, cadence_1.parseCadenceToCron)(habit.cadence);
+            if (cronSchedule === null)
+                continue;
+            jobs.push({
+                id: `${this.agent}:${habit.name}:cadence`,
+                agent: this.agent,
+                taskId: habit.name,
+                schedule: cronSchedule,
+                lastRun: habit.lastRun,
+                command: `${this.deps.ouroPath} poke ${this.agent} --habit ${habit.name} --trigger ${this.platform === "darwin" ? "launchd" : "cron"}`,
+                taskPath: path.join(this.habitsDir, `${habit.name}.md`),
+            });
+        }
+        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;
+    }
+    rejectReservedCronNamespaceHabit(habit) {
+        if (!habit.name.startsWith("await."))
+            return false;
+        this.recordHabitParseError(`${habit.name}.md`, "habit names cannot start with reserved cron namespace 'await.'");
+        return true;
+    }
+    recordDegradedHabitError(file, habit) {
+        const prefix = "habit definition degraded: ";
+        if (habit.status !== "degraded") {
+            this.parseErrors = this.parseErrors.filter((entry) => entry.file !== file || !entry.error.startsWith(prefix));
+            return;
+        }
+        const error = `${prefix}${habit.degradedReason}`;
+        if (this.parseErrors.some((entry) => entry.file === file && entry.error === error))
+            return;
+        this.parseErrors = this.parseErrors.filter((entry) => entry.file !== file || !entry.error.startsWith(prefix));
+        this.recordHabitParseError(file, error);
+    }
+    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}`;
+        return `overdue:last-run:${habit.lastRun}:cadence:${habit.cadence}`;
+    }
+    jobOccurrenceId(job, trigger) {
+        return `job:${job.id}:${trigger}:last-run:${job.lastRun ?? "never"}`;
+    }
+    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;