clementine-agent 1.0.0

package/dist/gateway/delivery-queue.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Clementine TypeScript — Delivery retry queue.
+ *
+ * File-backed queue for messages that failed to deliver.
+ * Retries up to 3 times on a 5-minute interval, then logs as permanently failed.
+ */
+import type { NotificationContext } from '../types.js';
+type SendFn = (text: string, context?: NotificationContext) => Promise<{
+    delivered: boolean;
+}>;
+export declare class DeliveryQueue {
+    private queue;
+    private timer;
+    private sendFn;
+    constructor();
+    /** Register the send function (from NotificationDispatcher). */
+    setSender(fn: SendFn): void;
+    /** Start the retry drain loop. */
+    start(): void;
+    stop(): void;
+    /** Enqueue a failed message for retry. */
+    enqueue(text: string, context?: NotificationContext): void;
+    /** Drain the queue: retry each message, remove successes and expired items. */
+    private drain;
+    get size(): number;
+    private load;
+    private save;
+}
+export {};
+//# sourceMappingURL=delivery-queue.d.ts.map

package/dist/gateway/delivery-queue.js

@@ -0,0 +1,110 @@
+/**
+ * Clementine TypeScript — Delivery retry queue.
+ *
+ * File-backed queue for messages that failed to deliver.
+ * Retries up to 3 times on a 5-minute interval, then logs as permanently failed.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import pino from 'pino';
+import { BASE_DIR } from '../config.js';
+import { logToDailyNote } from './cron-scheduler.js';
+const logger = pino({ name: 'clementine.delivery-queue' });
+const QUEUE_FILE = path.join(BASE_DIR, 'delivery-queue.json');
+const MAX_ATTEMPTS = 3;
+const RETRY_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+export class DeliveryQueue {
+    queue = [];
+    timer = null;
+    sendFn = null;
+    constructor() {
+        this.load();
+    }
+    /** Register the send function (from NotificationDispatcher). */
+    setSender(fn) {
+        this.sendFn = fn;
+    }
+    /** Start the retry drain loop. */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => this.drain(), RETRY_INTERVAL_MS);
+        // Also do an immediate drain if there are queued items from a previous run
+        if (this.queue.length > 0) {
+            setTimeout(() => this.drain(), 10_000); // brief delay to let channels connect
+        }
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** Enqueue a failed message for retry. */
+    enqueue(text, context) {
+        const now = new Date().toISOString();
+        this.queue.push({
+            text,
+            context,
+            attempts: 1, // already tried once (the initial send that failed)
+            firstAttempt: now,
+            lastAttempt: now,
+        });
+        this.save();
+        logger.info({ queueSize: this.queue.length }, 'Message queued for retry');
+    }
+    /** Drain the queue: retry each message, remove successes and expired items. */
+    async drain() {
+        if (this.queue.length === 0 || !this.sendFn)
+            return;
+        logger.debug({ queueSize: this.queue.length }, 'Draining delivery queue');
+        const remaining = [];
+        for (const msg of this.queue) {
+            msg.attempts++;
+            msg.lastAttempt = new Date().toISOString();
+            try {
+                const result = await this.sendFn(msg.text, msg.context);
+                if (result.delivered) {
+                    logger.info({ attempts: msg.attempts }, 'Queued message delivered on retry');
+                    continue; // success — don't keep in queue
+                }
+            }
+            catch (err) {
+                logger.debug({ err }, 'Retry delivery attempt failed');
+            }
+            if (msg.attempts >= MAX_ATTEMPTS) {
+                // Permanently failed — log to daily note so the user can find it
+                const preview = msg.text.slice(0, 100).replace(/\n/g, ' ');
+                logToDailyNote(`**[Delivery permanently failed]** (${msg.attempts} attempts): ${preview}`);
+                logger.warn({ attempts: msg.attempts, preview }, 'Message permanently failed delivery — logged to daily note');
+                continue; // drop from queue
+            }
+            remaining.push(msg);
+        }
+        this.queue = remaining;
+        this.save();
+    }
+    get size() {
+        return this.queue.length;
+    }
+    load() {
+        if (!existsSync(QUEUE_FILE))
+            return;
+        try {
+            this.queue = JSON.parse(readFileSync(QUEUE_FILE, 'utf-8'));
+        }
+        catch {
+            logger.warn('Failed to parse delivery queue file — starting fresh');
+            this.queue = [];
+        }
+    }
+    save() {
+        try {
+            writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
+        }
+        catch (err) {
+            logger.debug({ err }, 'Failed to persist delivery queue');
+        }
+    }
+}
+//# sourceMappingURL=delivery-queue.js.map

package/dist/gateway/heartbeat-scheduler.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Clementine TypeScript — Heartbeat scheduler.
+ *
+ * HeartbeatScheduler: periodic general check-ins using setInterval.
+ * Channel-agnostic — sends notifications via the NotificationDispatcher.
+ */
+import type { HeartbeatWorkItem } from '../types.js';
+import type { CronScheduler } from './cron-scheduler.js';
+import type { NotificationDispatcher } from './notifications.js';
+import type { Gateway } from './router.js';
+export declare class HeartbeatScheduler {
+    private readonly stateFile;
+    private gateway;
+    private dispatcher;
+    private lastState;
+    private timer;
+    private running;
+    private lastSelfImproveDate;
+    private lastConsolidationDate;
+    private lastAgentSiRuns;
+    private cronScheduler;
+    private runLog;
+    /** Wire up the cron scheduler so daily plan suggestions can be applied. */
+    setCronScheduler(cs: CronScheduler): void;
+    private getLastAgentSiRun;
+    private setLastAgentSiRun;
+    constructor(gateway: Gateway, dispatcher: NotificationDispatcher);
+    start(): void;
+    stop(): void;
+    runManual(): Promise<string>;
+    private heartbeatTick;
+    /**
+     * Proactive insight check — gather signals, evaluate urgency, send if warranted.
+     * Runs as a lightweight Haiku call, separate from the main heartbeat LLM invocation.
+     */
+    private runInsightCheck;
+    /** Called when user replies to a proactive message — resets cooldown. */
+    recordInsightAcknowledged(): void;
+    private readHeartbeatConfig;
+    private loadState;
+    private saveState;
+    private computeStateFingerprint;
+    private computeChangesSummary;
+    /**
+     * Summarise recent chat/cron activity from transcripts so the heartbeat
+     * agent knows what happened since the last beat.
+     */
+    private getRecentActivitySummary;
+    /**
+     * Load active goal summaries for injection into heartbeat prompts.
+     * Returns null if no active goals exist.
+     */
+    static loadGoalSummary(): string | null;
+    /**
+     * Enrich top active goals with relevant memory snippets.
+     * Searches FTS5 memory for each goal's title+description to surface
+     * recent conversations and facts the heartbeat agent can act on.
+     */
+    private enrichGoalsWithMemory;
+    /**
+     * Proactively advance goals by writing trigger files for the cron scheduler
+     * to pick up. Scores ALL active goals — not just stale ones — so high-priority
+     * goals with pending nextActions get worked on even if recently updated.
+     *
+     * Conservative: max 2 triggers per tick, skips if triggers are already pending.
+     */
+    private advanceGoals;
+    /**
+     * Process pending inbox items. For each .md file in INBOX_DIR:
+     * - Routes to the gateway as a cron-style task for the agent to triage
+     * - The agent determines the intent (task, reference, reminder) and acts
+     * - Processed files are moved to a _processed subfolder
+     *
+     * Conservative: processes at most 3 items per heartbeat tick.
+     */
+    private processInbox;
+    static getTimeContext(hour: number): string;
+    private static shouldSuppressMessage;
+    private pruneReportedTopics;
+    private buildDedupContext;
+    private static extractReportedTopics;
+    private static stripTopicTags;
+    static loadWorkQueue(): HeartbeatWorkItem[];
+    private static saveWorkQueue;
+    private claimNextItem;
+    private completeItem;
+    private failItem;
+    static enqueueWork(opts: {
+        description: string;
+        prompt: string;
+        source: string;
+        priority?: 'high' | 'normal';
+        maxTurns?: number;
+        tier?: number;
+        agentSlug?: string;
+    }): string;
+    private shouldInvokeAgent;
+}
+//# sourceMappingURL=heartbeat-scheduler.d.ts.map