clementine-agent 1.0.13 → 1.0.15

package/dist/gateway/notifications.js

@@ -10,6 +10,20 @@ import { DeliveryQueue } from './delivery-queue.js';
 const logger = pino({ name: 'clementine.notifications' });
 /** Safety cap — prevent runaway messages, but each channel handles its own chunking/limits. */
 const MAX_MESSAGE_LENGTH = 8000;
+/** Map a sessionKey prefix to the registered channel name that owns it. */
+function channelForSessionKey(sessionKey) {
+    if (sessionKey.startsWith('discord:'))
+        return 'discord';
+    if (sessionKey.startsWith('slack:'))
+        return 'slack';
+    if (sessionKey.startsWith('telegram:'))
+        return 'telegram';
+    if (sessionKey.startsWith('whatsapp:'))
+        return 'whatsapp';
+    if (sessionKey.startsWith('dashboard:'))
+        return 'dashboard';
+    return null;
+}
 export class NotificationDispatcher {
     senders = new Map();
     _retryQueue;
@@ -52,9 +66,20 @@ export class NotificationDispatcher {
         const capped = text.length > MAX_MESSAGE_LENGTH
             ? text.slice(0, MAX_MESSAGE_LENGTH - 20) + '\n\n_(truncated)_'
             : text;
+        // If sessionKey is set, route only to the channel that owns it.
+        // Fan out to all channels only when no originating channel is known.
+        const targetChannel = context?.sessionKey ? channelForSessionKey(context.sessionKey) : null;
+        const scopedSenders = [];
+        if (targetChannel && this.senders.has(targetChannel)) {
+            scopedSenders.push([targetChannel, this.senders.get(targetChannel)]);
+        }
+        else {
+            for (const entry of this.senders)
+                scopedSenders.push(entry);
+        }
         const channelErrors = {};
         let anySuccess = false;
-        for (const [name, sender] of this.senders) {
+        for (const [name, sender] of scopedSenders) {
             try {
                 await sender(capped, context);
                 anySuccess = true;

package/dist/gateway/router.js

@@ -185,14 +185,14 @@ export class Gateway {
         try {
             const agentReply = await this.handleMessage(sessionKey, syntheticPrompt);
             if (agentReply?.trim()) {
-                await this._dispatcher?.send(agentReply);
+                await this._dispatcher?.send(agentReply, { sessionKey });
                 logger.info({ sessionKey }, 'Deep mode result delivered via agent follow-up + dispatcher');
             }
         }
         catch (err) {
             logger.warn({ err, sessionKey }, 'Deep mode agent follow-up failed — using raw fallback');
             if (rawFallback.trim()) {
-                await this._dispatcher?.send(rawFallback.slice(0, 1500))
+                await this._dispatcher?.send(rawFallback.slice(0, 1500), { sessionKey })
                     .catch(async (e) => {
                     // Both paths failed — surface it instead of swallowing at debug level.
                     logger.warn({ err: e, sessionKey }, 'Deep mode fallback delivery failed — persisting to daily note');

package/dist/memory/store.d.ts

@@ -22,6 +22,26 @@ export declare class MemoryStore {
      * Create the database and schema if needed.
      */
     initialize(): void;
+    private _stmtLogSkillUse;
+    /**
+     * Record that a skill was retrieved and injected into a query context.
+     * Outcome is left null; a follow-up could backfill from reflection scores.
+     */
+    logSkillUse(row: {
+        skillName: string;
+        sessionKey?: string | null;
+        queryText?: string | null;
+        score?: number | null;
+        agentSlug?: string | null;
+    }): void;
+    /** Aggregate skill usage stats keyed by skill_name. */
+    skillUsageStats(windowDays?: number): Map<string, {
+        retrievals: number;
+        lastRetrievedAt: string | null;
+        avgScore: number | null;
+    }>;
+    /** Number of times a skill has been retrieved (all time). */
+    skillRetrievalCount(skillName: string): number;
     /**
      * Close the database connection.
      */

package/dist/memory/store.js

@@ -405,8 +405,72 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_sf_sync_local ON sf_sync_log(local_table, local_id);
       CREATE INDEX IF NOT EXISTS idx_sf_sync_sfid ON sf_sync_log(sf_id);
       CREATE INDEX IF NOT EXISTS idx_sf_sync_status ON sf_sync_log(sync_status);
+
+      CREATE TABLE IF NOT EXISTS skill_usage (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        skill_name TEXT NOT NULL,
+        session_key TEXT,
+        query_text TEXT,
+        retrieved_at TEXT NOT NULL DEFAULT (datetime('now')),
+        score REAL,
+        outcome TEXT,
+        agent_slug TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_skill_usage_name ON skill_usage(skill_name, retrieved_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_skill_usage_time ON skill_usage(retrieved_at DESC);
     `);
     }
+    // ── Skill usage telemetry ─────────────────────────────────────────
+    _stmtLogSkillUse = null;
+    /**
+     * Record that a skill was retrieved and injected into a query context.
+     * Outcome is left null; a follow-up could backfill from reflection scores.
+     */
+    logSkillUse(row) {
+        try {
+            if (!this._stmtLogSkillUse) {
+                this._stmtLogSkillUse = this.conn.prepare('INSERT INTO skill_usage (skill_name, session_key, query_text, score, agent_slug) VALUES (?, ?, ?, ?, ?)');
+            }
+            this._stmtLogSkillUse.run(row.skillName, row.sessionKey ?? null, row.queryText ? row.queryText.slice(0, 200) : null, row.score ?? null, row.agentSlug ?? null);
+        }
+        catch {
+            // Best-effort — telemetry must never break retrieval.
+        }
+    }
+    /** Aggregate skill usage stats keyed by skill_name. */
+    skillUsageStats(windowDays = 7) {
+        const out = new Map();
+        try {
+            const rows = this.conn.prepare(`SELECT skill_name,
+                COUNT(*) AS retrievals,
+                MAX(retrieved_at) AS last_retrieved_at,
+                AVG(score) AS avg_score
+         FROM skill_usage
+         WHERE retrieved_at >= datetime('now', ?)
+         GROUP BY skill_name`).all(`-${Math.max(1, Math.floor(windowDays))} days`);
+            for (const r of rows) {
+                out.set(r.skill_name, {
+                    retrievals: r.retrievals,
+                    lastRetrievedAt: r.last_retrieved_at,
+                    avgScore: r.avg_score,
+                });
+            }
+        }
+        catch {
+            // Table may not exist yet on legacy DBs — caller should tolerate empty.
+        }
+        return out;
+    }
+    /** Number of times a skill has been retrieved (all time). */
+    skillRetrievalCount(skillName) {
+        try {
+            const row = this.conn.prepare('SELECT COUNT(*) AS cnt FROM skill_usage WHERE skill_name = ?').get(skillName);
+            return row?.cnt ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
     /**
      * Close the database connection.
      */

package/dist/types.d.ts

@@ -104,6 +104,8 @@ export type OnTextCallback = (text: string) => Promise<void>;
 export type OnToolActivityCallback = (toolName: string, toolInput: Record<string, unknown>) => Promise<void>;
 export interface NotificationContext {
     agentSlug?: string;
+    /** When set, the dispatcher routes the message back to the channel that owns this session. */
+    sessionKey?: string;
 }
 export type NotificationSender = (text: string, context?: NotificationContext) => Promise<void>;
 /** Policy governing autonomous outbound email sending for an agent. */
@@ -192,6 +194,7 @@ export interface HeartbeatState {
     lastSelfImproveDate?: string;
     lastConsolidationDate?: string;
     lastAgentSiRuns?: Record<string, string>;
+    lastSkillDecayDate?: string;
     /** Proactive insight engine state */
     insightState?: {
         sentToday: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",