comisai 1.0.4

package/node_modules/@comis/scheduler/dist/heartbeat/resilience-tracker.js

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Resilience tracker: pure functions for heartbeat backoff, error
+ * classification, alert decisions, and recovery detection.
+ */
+/**
+ * Backoff schedule in milliseconds: [30s, 1m, 5m, 15m, 60m].
+ * Matches CronScheduler's ERROR_BACKOFF_SCHEDULE_MS.
+ */
+export const HEARTBEAT_BACKOFF_SCHEDULE_MS = Object.freeze([
+    30_000, 60_000, 300_000, 900_000, 3_600_000,
+]);
+/** Permanent error message patterns (lowercase match). */
+const PERMANENT_PATTERNS = [
+    "not found",
+    "not enabled",
+    "not configured",
+    "invalid",
+    "validation",
+    "unauthorized",
+    "forbidden",
+];
+/**
+ * Compute backoff delay based on consecutive error count.
+ *
+ * Returns 0 for errors <= 0, otherwise indexes into the backoff schedule
+ * clamped to array bounds: index = min(consecutiveErrors - 1, length - 1).
+ */
+export function computeBackoffMs(consecutiveErrors) {
+    if (consecutiveErrors <= 0)
+        return 0;
+    const index = Math.min(consecutiveErrors - 1, HEARTBEAT_BACKOFF_SCHEDULE_MS.length - 1);
+    return HEARTBEAT_BACKOFF_SCHEDULE_MS[index];
+}
+/**
+ * Classify an error for retry decisions.
+ *
+ * Non-Error objects are treated as transient (unknown cause).
+ * Error messages are matched against permanent patterns (case-insensitive).
+ * Everything else is transient (retryable).
+ */
+export function classifyError(error) {
+    if (!(error instanceof Error))
+        return "transient";
+    const msg = error.message.toLowerCase();
+    for (const pattern of PERMANENT_PATTERNS) {
+        if (msg.includes(pattern))
+            return "permanent";
+    }
+    return "transient";
+}
+/**
+ * Decide whether to fire a heartbeat failure alert.
+ *
+ * - Permanent errors: alert on first failure (consecutiveErrors >= 1) if cooldown expired
+ * - Transient errors: alert only when consecutiveErrors >= alertThreshold AND cooldown expired
+ * - Cooldown active: suppress alert regardless of error count
+ */
+export function shouldFireAlert(opts) {
+    const { consecutiveErrors, alertThreshold, lastAlertMs, cooldownMs, nowMs, classification, } = opts;
+    // Check cooldown first (applies to both transient and permanent)
+    if (lastAlertMs > 0 && nowMs - lastAlertMs < cooldownMs) {
+        return { shouldAlert: false, reason: "cooldown-active" };
+    }
+    // Permanent errors: alert on first failure
+    if (classification === "permanent" && consecutiveErrors >= 1) {
+        return { shouldAlert: true, reason: "permanent-error" };
+    }
+    // Transient errors: must meet threshold
+    if (consecutiveErrors < alertThreshold) {
+        return { shouldAlert: false, reason: "below-threshold" };
+    }
+    return { shouldAlert: true, reason: "threshold-exceeded" };
+}
+/**
+ * Detect recovery: returns true if the previous tick had errors.
+ * Used to log recovery events when a heartbeat succeeds after failures.
+ */
+export function isRecovery(previousErrors) {
+    return previousErrors > 0;
+}

package/node_modules/@comis/scheduler/dist/heartbeat/response-cache.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Heartbeat response cache: TTL-based cache for heartbeat query+response
+ * pairs. Deduplicates identical heartbeat queries within a TTL window to
+ * avoid redundant LLM calls when the same contextual input produces the
+ * same result.
+ *
+ * Follows the same pattern as createDuplicateDetector in this package.
+ *
+ * @module
+ */
+/** Heartbeat response cache interface. */
+export interface HeartbeatResponseCache {
+    /** Get cached response for a prompt hash. Returns undefined on miss. */
+    get(promptHash: string): string | undefined;
+    /** Store a response with TTL. */
+    set(promptHash: string, response: string): void;
+    /** Clear all cached entries. */
+    clear(): void;
+    /** Number of cached entries. */
+    size(): number;
+}
+/**
+ * Compute a compact hash key from heartbeat prompt text and event digest.
+ *
+ * @param promptText - The heartbeat prompt text
+ * @param eventDigest - A digest of system events / HEARTBEAT.md content
+ * @returns 16-character hex hash
+ */
+export declare function hashHeartbeatPrompt(promptText: string, eventDigest: string): string;
+/**
+ * Create a heartbeat response cache with TTL expiration and max entry limit.
+ * Delegates to createTTLCache from @comis/shared.
+ *
+ * @param opts.ttlMs - Time-to-live in milliseconds (default: 30 minutes)
+ * @param opts.maxEntries - Maximum cache entries (default: 50)
+ * @param opts.nowMs - Injectable clock for deterministic testing (default: Date.now)
+ */
+export declare function createHeartbeatResponseCache(opts?: {
+    ttlMs?: number;
+    maxEntries?: number;
+    nowMs?: () => number;
+}): HeartbeatResponseCache;

package/node_modules/@comis/scheduler/dist/heartbeat/response-cache.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Heartbeat response cache: TTL-based cache for heartbeat query+response
+ * pairs. Deduplicates identical heartbeat queries within a TTL window to
+ * avoid redundant LLM calls when the same contextual input produces the
+ * same result.
+ *
+ * Follows the same pattern as createDuplicateDetector in this package.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { createTTLCache } from "@comis/shared";
+// ---------------------------------------------------------------------------
+// Hash helper
+// ---------------------------------------------------------------------------
+/**
+ * Compute a compact hash key from heartbeat prompt text and event digest.
+ *
+ * @param promptText - The heartbeat prompt text
+ * @param eventDigest - A digest of system events / HEARTBEAT.md content
+ * @returns 16-character hex hash
+ */
+export function hashHeartbeatPrompt(promptText, eventDigest) {
+    return createHash("sha256")
+        .update(promptText + "\0" + eventDigest)
+        .digest("hex")
+        .slice(0, 16);
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a heartbeat response cache with TTL expiration and max entry limit.
+ * Delegates to createTTLCache from @comis/shared.
+ *
+ * @param opts.ttlMs - Time-to-live in milliseconds (default: 30 minutes)
+ * @param opts.maxEntries - Maximum cache entries (default: 50)
+ * @param opts.nowMs - Injectable clock for deterministic testing (default: Date.now)
+ */
+export function createHeartbeatResponseCache(opts) {
+    const cache = createTTLCache({
+        ttlMs: opts?.ttlMs ?? 30 * 60 * 1000,
+        maxEntries: opts?.maxEntries ?? 50,
+        nowMs: opts?.nowMs,
+    });
+    return {
+        get(promptHash) {
+            return cache.get(promptHash);
+        },
+        set(promptHash, response) {
+            cache.set(promptHash, response);
+        },
+        clear() {
+            cache.clear();
+        },
+        size() {
+            return cache.size();
+        },
+    };
+}

package/node_modules/@comis/scheduler/dist/heartbeat/response-processor.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Response processor for heartbeat LLM responses.
+ *
+ * Pure functions that classify LLM heartbeat responses into a discriminated
+ * union outcome (heartbeat_ok vs deliver). Handles:
+ * - HEARTBEAT_OK token detection with HTML/Markdown stripping
+ * - ackMaxChars threshold for soft acknowledgments
+ * - Response prefix removal
+ * - Media bypass
+ * - Empty reply handling
+ *
+ * Session side-effects (transcript pruning, updatedAt preservation, dedup state)
+ * are handled by the caller based on the returned outcome.
+ */
+/** Discriminated union result of heartbeat response classification. */
+export type HeartbeatResponseOutcome = {
+    kind: "heartbeat_ok";
+    reason: "token" | "ack_under_threshold" | "empty_reply";
+    cleanedText: string;
+} | {
+    kind: "deliver";
+    text: string;
+    hasMedia: boolean;
+};
+/** Input to classifyHeartbeatResponse. */
+export interface ClassifyHeartbeatInput {
+    text: string | null | undefined;
+    hasMedia: boolean;
+    ackMaxChars: number;
+}
+/** Input to the processHeartbeatResponse orchestrator. */
+export interface ProcessHeartbeatInput {
+    responseText: string | null | undefined;
+    responsePrefix: string | undefined;
+    ackMaxChars: number;
+    hasMedia: boolean;
+}
+/**
+ * Strip HTML tags and common Markdown wrappers to expose tokens.
+ * Not a full parser -- just enough to find HEARTBEAT_OK in LLM output.
+ */
+export declare function stripMarkup(text: string): string;
+/**
+ * Detect and strip HEARTBEAT_OK from text.
+ *
+ * Token is recognized at leading/trailing positions only.
+ * Handles up to 4 trailing non-word characters (e.g., "HEARTBEAT_OK!!!").
+ * Token embedded mid-sentence is NOT detected (prevents false positives).
+ */
+export declare function stripHeartbeatToken(text: string): {
+    stripped: string;
+    hadToken: boolean;
+};
+/**
+ * Strip a configurable response prefix from the beginning of text.
+ * Case-sensitive. Returns text unchanged if prefix does not match or is absent.
+ */
+export declare function stripResponsePrefix(text: string, prefix: string | undefined): string;
+/**
+ * Classify a heartbeat LLM response into an outcome.
+ *
+ * Check order:
+ * 1. Media bypass -- always deliver
+ * 2. Empty/null reply -- treated as HEARTBEAT_OK
+ * 3. Token detection + ackMaxChars threshold
+ */
+export declare function classifyHeartbeatResponse(input: ClassifyHeartbeatInput): HeartbeatResponseOutcome;
+/**
+ * Orchestrator: applies response prefix stripping then classifies.
+ *
+ * This is the main entry point called from agent-heartbeat-source.ts
+ * between execution (step 10) and delivery (step 11).
+ */
+export declare function processHeartbeatResponse(input: ProcessHeartbeatInput): HeartbeatResponseOutcome;

package/node_modules/@comis/scheduler/dist/heartbeat/response-processor.js

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Response processor for heartbeat LLM responses.
+ *
+ * Pure functions that classify LLM heartbeat responses into a discriminated
+ * union outcome (heartbeat_ok vs deliver). Handles:
+ * - HEARTBEAT_OK token detection with HTML/Markdown stripping
+ * - ackMaxChars threshold for soft acknowledgments
+ * - Response prefix removal
+ * - Media bypass
+ * - Empty reply handling
+ *
+ * Session side-effects (transcript pruning, updatedAt preservation, dedup state)
+ * are handled by the caller based on the returned outcome.
+ */
+import { HEARTBEAT_OK_TOKEN } from "./relevance-filter.js";
+// ---------------------------------------------------------------------------
+// Regex constants
+// ---------------------------------------------------------------------------
+/** Matches HTML tags (not a full parser -- sufficient for token exposure). */
+const HTML_TAG_RE = /<[^>]+>/g;
+/** Matches leading/trailing Markdown wrapper characters (backticks, bold, italic, strikethrough). */
+const MARKDOWN_WRAPPER_RE = /^[`*_~]+|[`*_~]+$/g;
+// ---------------------------------------------------------------------------
+// Pure functions
+// ---------------------------------------------------------------------------
+/**
+ * Strip HTML tags and common Markdown wrappers to expose tokens.
+ * Not a full parser -- just enough to find HEARTBEAT_OK in LLM output.
+ */
+export function stripMarkup(text) {
+    return text
+        .replace(HTML_TAG_RE, "")
+        .replace(MARKDOWN_WRAPPER_RE, "")
+        .trim();
+}
+/**
+ * Detect and strip HEARTBEAT_OK from text.
+ *
+ * Token is recognized at leading/trailing positions only.
+ * Handles up to 4 trailing non-word characters (e.g., "HEARTBEAT_OK!!!").
+ * Token embedded mid-sentence is NOT detected (prevents false positives).
+ */
+export function stripHeartbeatToken(text) {
+    const cleaned = stripMarkup(text);
+    // Exact match: entire text is the token with optional trailing punctuation
+    const exactRe = new RegExp(`^${HEARTBEAT_OK_TOKEN}\\W{0,4}$`);
+    if (exactRe.test(cleaned)) {
+        return { stripped: "", hadToken: true };
+    }
+    // Leading token: token at start followed by whitespace and remaining text
+    const leadingRe = new RegExp(`^${HEARTBEAT_OK_TOKEN}\\W{0,4}\\s+`);
+    if (leadingRe.test(cleaned)) {
+        return { stripped: cleaned.replace(leadingRe, "").trim(), hadToken: true };
+    }
+    // Trailing token: text followed by whitespace and token at end
+    const trailingRe = new RegExp(`\\s+${HEARTBEAT_OK_TOKEN}\\W{0,4}$`);
+    if (trailingRe.test(cleaned)) {
+        return { stripped: cleaned.replace(trailingRe, "").trim(), hadToken: true };
+    }
+    return { stripped: cleaned, hadToken: false };
+}
+/**
+ * Strip a configurable response prefix from the beginning of text.
+ * Case-sensitive. Returns text unchanged if prefix does not match or is absent.
+ */
+export function stripResponsePrefix(text, prefix) {
+    if (!prefix)
+        return text;
+    if (text.startsWith(prefix)) {
+        return text.slice(prefix.length);
+    }
+    return text;
+}
+/**
+ * Classify a heartbeat LLM response into an outcome.
+ *
+ * Check order:
+ * 1. Media bypass -- always deliver
+ * 2. Empty/null reply -- treated as HEARTBEAT_OK
+ * 3. Token detection + ackMaxChars threshold
+ */
+export function classifyHeartbeatResponse(input) {
+    const { text, hasMedia, ackMaxChars } = input;
+    // Media bypass -- always deliver
+    if (hasMedia) {
+        return { kind: "deliver", text: text?.trim() ?? "", hasMedia: true };
+    }
+    // Empty/null reply treated as HEARTBEAT_OK
+    if (!text || !text.trim()) {
+        return { kind: "heartbeat_ok", reason: "empty_reply", cleanedText: "" };
+    }
+    const { stripped, hadToken } = stripHeartbeatToken(text);
+    if (hadToken) {
+        // Token found -- check if remaining text is under threshold
+        if (stripped.length <= ackMaxChars) {
+            return { kind: "heartbeat_ok", reason: "token", cleanedText: stripped };
+        }
+        // Token found but substantial remaining text -- deliver the stripped text
+        return { kind: "deliver", text: stripped, hasMedia: false };
+    }
+    // No token, no media, non-empty -- deliver as-is
+    return { kind: "deliver", text: text.trim(), hasMedia: false };
+}
+/**
+ * Orchestrator: applies response prefix stripping then classifies.
+ *
+ * This is the main entry point called from agent-heartbeat-source.ts
+ * between execution (step 10) and delivery (step 11).
+ */
+export function processHeartbeatResponse(input) {
+    const { responseText, responsePrefix, ackMaxChars, hasMedia } = input;
+    // Handle null/undefined before prefix stripping
+    if (responseText == null) {
+        return classifyHeartbeatResponse({ text: null, hasMedia, ackMaxChars });
+    }
+    // Strip configurable response prefix
+    const prefixStripped = stripResponsePrefix(responseText, responsePrefix);
+    return classifyHeartbeatResponse({ text: prefixStripped, hasMedia, ackMaxChars });
+}

package/node_modules/@comis/scheduler/dist/heartbeat/wake-coalescer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Wake Coalescer: Centralized wake dispatch with debouncing and priority deduplication.
+ *
+ * Prevents duplicate heartbeat executions from rapid-fire wake requests by:
+ * - Debouncing within a configurable window (default 250ms)
+ * - Applying priority-based deduplication (higher overrides lower)
+ * - Automatically retrying when heartbeat is in-flight
+ * - Tracking pending wakes per key for independent coalescing
+ *
+ * Implements debouncing, priority deduplication, and in-flight retry.
+ *
+ * @module
+ */
+import type { WakeCoalescerDeps, WakeCoalescer } from "./wake-types.js";
+/**
+ * Create a wake coalescer that debounces rapid heartbeat wake requests.
+ *
+ * @param deps - Dependencies including runOnce, logger, and optional timing config
+ * @returns WakeCoalescer with requestHeartbeatNow and shutdown methods
+ */
+export declare function createWakeCoalescer(deps: WakeCoalescerDeps): WakeCoalescer;

package/node_modules/@comis/scheduler/dist/heartbeat/wake-coalescer.js

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Wake Coalescer: Centralized wake dispatch with debouncing and priority deduplication.
+ *
+ * Prevents duplicate heartbeat executions from rapid-fire wake requests by:
+ * - Debouncing within a configurable window (default 250ms)
+ * - Applying priority-based deduplication (higher overrides lower)
+ * - Automatically retrying when heartbeat is in-flight
+ * - Tracking pending wakes per key for independent coalescing
+ *
+ * Implements debouncing, priority deduplication, and in-flight retry.
+ *
+ * @module
+ */
+import { WAKE_PRIORITY } from "./wake-types.js";
+/**
+ * Create a wake coalescer that debounces rapid heartbeat wake requests.
+ *
+ * @param deps - Dependencies including runOnce, logger, and optional timing config
+ * @returns WakeCoalescer with requestHeartbeatNow and shutdown methods
+ */
+export function createWakeCoalescer(deps) {
+    const { runOnce, logger } = deps;
+    const coalesceWindowMs = deps.coalesceWindowMs ?? 250;
+    const busyRetryMs = deps.busyRetryMs ?? 1000;
+    const getNow = deps.nowMs ?? Date.now;
+    /** Pending wakes keyed by dispatch key. */
+    const pending = new Map();
+    /** Keys currently executing runOnce. */
+    const inFlight = new Set();
+    /**
+     * Fire the debounced wake: set in-flight, run once, clear in-flight.
+     */
+    async function dispatch(key, reason) {
+        inFlight.add(key);
+        logger.debug({ reason, key }, "Wake dispatching");
+        try {
+            await runOnce();
+        }
+        finally {
+            inFlight.delete(key);
+            logger.debug({ key }, "Wake dispatch complete");
+        }
+    }
+    function requestHeartbeatNow(reason, key = "global") {
+        const priority = WAKE_PRIORITY[reason];
+        logger.debug({ reason, key, priority }, "Wake request received");
+        // ---- In-flight handling ----
+        if (inFlight.has(key)) {
+            const existing = pending.get(key);
+            if (existing?.retryTimer !== undefined) {
+                // Retry already pending -- only upgrade priority if higher
+                if (priority > existing.priority) {
+                    existing.reason = reason;
+                    existing.priority = priority;
+                    logger.debug({ oldReason: existing.reason, newReason: reason, key }, "Wake retry priority upgraded");
+                }
+                logger.debug({ reason, key }, "Wake deferred (in-flight), retry already pending");
+                return;
+            }
+            // Schedule a single retry after busyRetryMs
+            const retryTimer = setTimeout(() => {
+                // Remove the retry entry and re-request
+                const entry = pending.get(key);
+                if (entry) {
+                    pending.delete(key);
+                }
+                requestHeartbeatNow(reason, key);
+            }, busyRetryMs);
+            retryTimer.unref();
+            // Store as pending with retry timer
+            pending.set(key, {
+                reason,
+                priority,
+                debounceTimer: undefined,
+                retryTimer,
+                requestedAt: getNow(),
+            });
+            logger.debug({ reason, key, busyRetryMs }, "Wake deferred (in-flight), retry scheduled");
+            return;
+        }
+        // ---- Priority-based coalescing ----
+        const existingPending = pending.get(key);
+        if (existingPending) {
+            if (priority > existingPending.priority) {
+                // Higher priority: replace reason and reset debounce timer
+                clearTimeout(existingPending.debounceTimer);
+                const oldReason = existingPending.reason;
+                existingPending.reason = reason;
+                existingPending.priority = priority;
+                const debounceTimer = setTimeout(() => {
+                    const entry = pending.get(key);
+                    if (!entry)
+                        return;
+                    pending.delete(key);
+                    void dispatch(key, entry.reason);
+                }, coalesceWindowMs);
+                debounceTimer.unref();
+                existingPending.debounceTimer = debounceTimer;
+                logger.debug({ oldReason, newReason: reason, key }, "Wake priority upgraded");
+            }
+            else {
+                // Lower or equal priority: coalesce (ignore, keep existing timer)
+                logger.debug({ reason, key, existingReason: existingPending.reason }, "Wake coalesced (lower/equal priority ignored)");
+            }
+            return;
+        }
+        // ---- New pending entry with debounce timer ----
+        const debounceTimer = setTimeout(() => {
+            const entry = pending.get(key);
+            if (!entry)
+                return;
+            pending.delete(key);
+            void dispatch(key, entry.reason);
+        }, coalesceWindowMs);
+        debounceTimer.unref();
+        pending.set(key, {
+            reason,
+            priority,
+            debounceTimer,
+            requestedAt: getNow(),
+        });
+    }
+    function shutdown() {
+        for (const [, entry] of pending) {
+            clearTimeout(entry.debounceTimer);
+            if (entry.retryTimer !== undefined) {
+                clearTimeout(entry.retryTimer);
+            }
+        }
+        pending.clear();
+        inFlight.clear();
+    }
+    return { requestHeartbeatNow, shutdown };
+}

package/node_modules/@comis/scheduler/dist/heartbeat/wake-types.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Wake coalescing types: priority-based deduplication for heartbeat wake dispatch.
+ *
+ * Reason kinds with priority ordering:
+ *   retry(0) < interval(1) < manual=hook=wake(2) < exec-event=cron(3)
+ *
+ * @module
+ */
+import type { SchedulerLogger } from "../shared-types.js";
+/** All recognized wake reason kinds for heartbeat dispatch. */
+export type WakeReasonKind = "retry" | "interval" | "manual" | "hook" | "wake" | "exec-event" | "cron";
+/**
+ * Priority map: higher number = higher priority.
+ * During coalescing, a higher-priority reason overrides a lower-priority one.
+ */
+export declare const WAKE_PRIORITY: Record<WakeReasonKind, number>;
+/** Internal state for a pending (debouncing) wake request. */
+export interface PendingWake {
+    reason: WakeReasonKind;
+    priority: number;
+    debounceTimer: ReturnType<typeof setTimeout>;
+    retryTimer?: ReturnType<typeof setTimeout>;
+    requestedAt: number;
+}
+/** Dependencies for the wake coalescer factory. */
+export interface WakeCoalescerDeps {
+    /** The function to invoke when the debounce window expires. */
+    runOnce: () => Promise<void>;
+    /** Logger instance for DEBUG-level wake tracing. */
+    logger: SchedulerLogger;
+    /** Debounce window in milliseconds. Default: 250. */
+    coalesceWindowMs?: number;
+    /** Retry delay when runOnce is in-flight. Default: 1000. */
+    busyRetryMs?: number;
+    /** Injectable clock for deterministic testing. Default: Date.now. */
+    nowMs?: () => number;
+}
+/** Public interface for the wake coalescer. */
+export interface WakeCoalescer {
+    /** Schedule a heartbeat wake. Fire-and-forget: debounces, deduplicates, and retries automatically. */
+    requestHeartbeatNow(reason: WakeReasonKind, key?: string): void;
+    /** Clear all pending debounce and retry timers (for clean shutdown). */
+    shutdown(): void;
+}

package/node_modules/@comis/scheduler/dist/heartbeat/wake-types.js

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Wake coalescing types: priority-based deduplication for heartbeat wake dispatch.
+ *
+ * Reason kinds with priority ordering:
+ *   retry(0) < interval(1) < manual=hook=wake(2) < exec-event=cron(3)
+ *
+ * @module
+ */
+/**
+ * Priority map: higher number = higher priority.
+ * During coalescing, a higher-priority reason overrides a lower-priority one.
+ */
+export const WAKE_PRIORITY = {
+    retry: 0,
+    interval: 1,
+    manual: 2,
+    hook: 2,
+    wake: 2,
+    "exec-event": 3,
+    cron: 3,
+};

package/node_modules/@comis/scheduler/dist/index.d.ts

@@ -0,0 +1,43 @@
+export type { SchedulerLogger } from "./shared-types.js";
+export type { CronJob } from "./cron/index.js";
+export { computeNextRunAtMs } from "./cron/index.js";
+export { createCronStore } from "./cron/index.js";
+export type { CronStore } from "./cron/index.js";
+export { createCronScheduler } from "./cron/index.js";
+export type { CronScheduler } from "./cron/index.js";
+export { createExecutionTracker } from "./execution/index.js";
+export type { ExecutionTracker, ExecutionLogEntry } from "./execution/index.js";
+export { HEARTBEAT_OK_TOKEN, createHeartbeatRunner } from "./heartbeat/index.js";
+export type { HeartbeatCheckResult, HeartbeatSourcePort, HeartbeatRunner } from "./heartbeat/index.js";
+export { resolveEffectiveHeartbeatConfig } from "./heartbeat/index.js";
+export type { EffectiveHeartbeatConfig } from "./heartbeat/index.js";
+export { createPerAgentHeartbeatRunner } from "./heartbeat/index.js";
+export type { PerAgentHeartbeatRunner, PerAgentHeartbeatRunnerDeps, HeartbeatAgentState } from "./heartbeat/index.js";
+export { createWakeCoalescer, WAKE_PRIORITY } from "./heartbeat/index.js";
+export type { WakeCoalescer, WakeCoalescerDeps, WakeReasonKind } from "./heartbeat/index.js";
+export { createDuplicateDetector, deliverHeartbeatNotification } from "./heartbeat/index.js";
+export type { DuplicateDetector, DeliveryBridgeDeps, DeliveryTarget, DeliveryOutcome, ChannelVisibilityConfig } from "./heartbeat/index.js";
+export { isInQuietHours, parseTimeToMinutes, getCurrentMinutesInTimezone } from "./heartbeat/index.js";
+export type { QuietHoursConfig } from "./heartbeat/index.js";
+export { createTaskExtractor } from "./tasks/task-extractor.js";
+export type { TaskExtractor, TaskExtractorDeps, ExtractionFn } from "./tasks/task-extractor.js";
+export { createTaskStore } from "./tasks/task-store.js";
+export type { TaskStore } from "./tasks/task-store.js";
+export type { ExtractedTask, TaskPriority, TaskStatus, TaskExtractionResult } from "./tasks/task-types.js";
+export { ExtractedTaskSchema, TaskExtractionResultSchema, TaskPrioritySchema, TaskStatusSchema } from "./tasks/task-types.js";
+export { scorePriority, rankTasks, PRIORITY_WEIGHTS } from "./tasks/task-priority.js";
+export type { PriorityScore } from "./tasks/task-priority.js";
+export { shouldBypassFileGates } from "./heartbeat/index.js";
+export type { HeartbeatTriggerKind } from "./heartbeat/index.js";
+export { resolveHeartbeatTriggerKind, buildHeartbeatPrompt, DEFAULT_HEARTBEAT_PROMPT, MEMORY_STATS_THRESHOLD } from "./heartbeat/index.js";
+export type { HeartbeatMemoryStats } from "./heartbeat/index.js";
+export { stripMarkup, stripHeartbeatToken, stripResponsePrefix, classifyHeartbeatResponse, processHeartbeatResponse } from "./heartbeat/index.js";
+export type { HeartbeatResponseOutcome, ClassifyHeartbeatInput, ProcessHeartbeatInput } from "./heartbeat/index.js";
+export { buildCronEventPrompt, buildExecEventPrompt } from "./heartbeat/index.js";
+export { shouldSkipHeartbeatOnlyDelivery } from "./heartbeat/index.js";
+export { createAgentHeartbeatSource, isQueueBusy, resolveHeartbeatSessionKey } from "./heartbeat/index.js";
+export type { AgentHeartbeatSourceDeps, HeartbeatSessionOps } from "./heartbeat/index.js";
+export { createSystemEventQueue } from "./system-events/index.js";
+export type { SystemEventQueue, SystemEventQueueDeps } from "./system-events/index.js";
+export { SystemEventEntrySchema } from "./system-events/index.js";
+export type { SystemEventEntry } from "./system-events/index.js";