clementine-agent 1.0.84 → 1.0.86

package/dist/agent/route-classifier.d.ts

@@ -23,6 +23,8 @@ export interface RouteDecision {
     confidence: number;
     reasoning: string;
 }
+/** Test-only: reset the cache between runs. */
+export declare function _resetRouteCache(): void;
 export declare function isDirectImperative(userMessage: string): {
     match: boolean;
     pattern?: string;

package/dist/agent/route-classifier.js

@@ -18,6 +18,49 @@
  */
 import pino from 'pino';
 const logger = pino({ name: 'clementine.route-classifier' });
+// ── LRU cache for repeated messages ──────────────────────────────────
+// Same text + same available-agents set → same decision. Skips the
+// Haiku LLM call entirely on cache hit (saves 1-2 seconds per repeat).
+// Bounded by both size and TTL so stale rosters can't cause wrong routes.
+const ROUTE_CACHE_MAX = 100;
+const ROUTE_CACHE_TTL_MS = 5 * 60 * 1000;
+// Insertion-ordered Map = LRU when we delete-and-reinsert on hit.
+const routeCache = new Map();
+function cacheKey(text, agents) {
+    // Trim + normalize whitespace so trailing-newline variations of the
+    // same message hit the same cache entry.
+    const normText = text.replace(/\s+/g, ' ').trim();
+    // Sort slugs so order doesn't matter; include count to invalidate on
+    // hire/fire (the agents array changes shape).
+    const slugFingerprint = agents.map(a => a.slug).sort().join(',');
+    return `${slugFingerprint}::${normText}`;
+}
+function cacheGet(key, now) {
+    const entry = routeCache.get(key);
+    if (!entry)
+        return null;
+    if (entry.expiresAt <= now) {
+        routeCache.delete(key);
+        return null;
+    }
+    // LRU touch: remove + re-insert to move to end of insertion order
+    routeCache.delete(key);
+    routeCache.set(key, entry);
+    return entry;
+}
+function cachePut(key, decision, now) {
+    routeCache.set(key, { decision, expiresAt: now + ROUTE_CACHE_TTL_MS });
+    while (routeCache.size > ROUTE_CACHE_MAX) {
+        const oldest = routeCache.keys().next().value;
+        if (oldest === undefined)
+            break;
+        routeCache.delete(oldest);
+    }
+}
+/** Test-only: reset the cache between runs. */
+export function _resetRouteCache() {
+    routeCache.clear();
+}
 /**
  * Direct-imperative guardrail.
  *
@@ -229,6 +272,15 @@ export async function classifyRoute(userMessage, agents, gateway) {
         logger.debug({ trigger: 'question-opener' }, 'Routing skipped — question-opener');
         return null;
     }
+    // Cache hit short-circuit — same message + same roster as a recent
+    // call gets the same decision without firing the Haiku classifier.
+    const now = Date.now();
+    const key = cacheKey(userMessage, agents);
+    const hit = cacheGet(key, now);
+    if (hit) {
+        logger.debug({ trigger: 'cache-hit', cachedAgent: hit.decision?.targetAgent ?? 'clementine' }, 'Route classifier cache hit');
+        return hit.decision;
+    }
     // LLM classifier for everything else.
     const prompt = buildPrompt(userMessage, agents);
     let raw;
@@ -239,6 +291,7 @@ export async function classifyRoute(userMessage, agents, gateway) {
     }
     catch (err) {
         logger.warn({ err }, 'Route classifier call failed');
+        // Don't cache failures — next call should retry the LLM.
         return null;
     }
     const decision = parseResponse(raw);
@@ -254,6 +307,7 @@ export async function classifyRoute(userMessage, agents, gateway) {
         decision.targetAgent = 'clementine';
         decision.confidence = Math.min(decision.confidence, 0.3);
     }
+    cachePut(key, decision, now);
     return decision;
 }
 //# sourceMappingURL=route-classifier.js.map

package/dist/cli/dashboard.js

@@ -1084,6 +1084,7 @@ function getAgentHeartbeats() {
                 silentTickCount: Number(state.silentTickCount ?? 0),
                 fingerprint: state.fingerprint ?? '',
                 lastSignalSummary: state.lastSignalSummary ?? null,
+                lastTickKind: state.lastTickKind ?? null,
                 lastTickAgoMs: lastTickMs ? now - lastTickMs : null,
                 nextCheckInMs: nextCheckMs ? nextCheckMs - now : null,
                 isDue: nextCheckMs > 0 && nextCheckMs <= now,
@@ -8977,6 +8978,26 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
   .desk-kpi-strip .dss-icon { font-size: 12px; opacity: 0.7; }
   .desk-kpi-strip .dss-val { font-weight: 700; color: var(--accent); }
 
+  /* ── Heartbeat Strip ────────────── */
+  .desk-hb-strip {
+    display: flex;
+    justify-content: center;
+    gap: 6px;
+    padding: 2px 12px;
+    font-size: 10px;
+    color: var(--text-muted);
+    min-height: 0;
+  }
+  .desk-hb-strip:empty { display: none; }
+  .desk-hb-strip .dss-item {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    white-space: nowrap;
+  }
+  .desk-hb-strip .dss-icon { font-size: 11px; opacity: 0.85; }
+  .desk-hb-strip .dss-val { font-weight: 600; color: var(--text-secondary); }
+
   /* ── Health Badge ──────────────────── */
   .desk-health-badge {
     display: none;
@@ -17272,6 +17293,9 @@ async function refreshTeam() {
             '</details>';
           }
 
+          // Heartbeat strip — last/next tick, populated async from /api/agent-heartbeats
+          var hbStrip = '<div class="desk-hb-strip" id="hb-' + a.slug + '"></div>';
+
           // SDR KPI strip (fetched async, populated by data attribute)
           var kpiStrip = '<div class="desk-kpi-strip" id="kpi-' + a.slug + '"></div>';
 
@@ -17299,6 +17323,7 @@ async function refreshTeam() {
               (actions ? '<div class="desk-actions">' + actions + '</div>' : '') +
             '</div>' +
             statsStrip +
+            hbStrip +
             kpiStrip +
             cronDetails +
           '</div>';
@@ -17312,6 +17337,54 @@ async function refreshTeam() {
 
         grid.innerHTML = cards.join('');
 
+        // Heartbeat strip — single batch fetch, populate per-agent (avoids N requests).
+        apiFetch('/api/agent-heartbeats').then(function(r) { return r.json(); }).then(function(hbList) {
+          if (!Array.isArray(hbList)) return;
+          var byAgent = {};
+          for (var i = 0; i < hbList.length; i++) byAgent[hbList[i].slug] = hbList[i];
+          agents.forEach(function(a) {
+            var hb = byAgent[a.slug];
+            var el = document.getElementById('hb-' + a.slug);
+            if (!el || !hb) return;
+            // "in 12 min" / "due now" / "10s ago tick"
+            var nextLabel;
+            if (hb.isDue) {
+              nextLabel = 'due now';
+            } else if (typeof hb.nextCheckInMs === 'number') {
+              var mins = Math.max(1, Math.round(hb.nextCheckInMs / 60000));
+              nextLabel = mins < 60 ? 'in ' + mins + 'm' : 'in ' + Math.floor(mins / 60) + 'h';
+            } else {
+              nextLabel = '—';
+            }
+            var lastLabel = hb.lastTickAt ? fmtTimeAgo(hb.lastTickAt) : 'never';
+            // Tick-kind icon — small visual signal
+            var kindIcon = '';
+            var kindTitle = '';
+            switch (hb.lastSignalSummary && hb.lastSignalSummary.indexOf('llm tick error') === 0
+              ? 'error' : '') {
+              case 'error':
+                kindIcon = '⚠'; kindTitle = 'Last tick errored — fell back to quiet cadence';
+                break;
+            }
+            // Use a literal field if available — backend exposes lastTickKind via state file
+            // (we read it through getAgentHeartbeats which preserves the field)
+            if (!kindIcon) {
+              switch (hb.lastTickKind) {
+                case 'acted':    kindIcon = '⚡'; kindTitle = 'Active — agent took action last tick'; break;
+                case 'quiet':    kindIcon = '◌'; kindTitle = 'Quiet — agent saw signals but had nothing to do'; break;
+                case 'silent':   kindIcon = '·'; kindTitle = 'Silent — fingerprint unchanged, backing off'; break;
+                case 'override': kindIcon = '◇'; kindTitle = 'Override — cadence set explicitly by the agent'; break;
+                default:         kindIcon = '·'; kindTitle = 'No tick recorded yet';
+              }
+            }
+            el.innerHTML =
+              '<span class="dss-item" title="' + kindTitle + '">' +
+                '<span class="dss-icon">' + kindIcon + '</span> ' +
+                '<span class="dss-val">' + lastLabel + '</span> · next ' + nextLabel +
+              '</span>';
+          });
+        }).catch(function() { /* heartbeat endpoint missing or daemon old — silently skip */ });
+
         // Async-fetch KPIs and health for each agent
         agents.forEach(function(a) {
           // KPI strip

package/dist/gateway/agent-heartbeat-manager.js

@@ -10,7 +10,7 @@
  * out. Per-agent failures are caught so one buggy agent can't crash the
  * daemon or stall others.
  */
-import { existsSync, mkdirSync, watch } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, watch } from 'node:fs';
 import path from 'node:path';
 import pino from 'pino';
 import { AGENTS_DIR, BASE_DIR } from '../config.js';
@@ -107,22 +107,15 @@ export class AgentHeartbeatManager {
                 if (!filename.endsWith('.json'))
                     return;
                 const slug = filename.replace(/\.json$/, '');
-                // Consume the sentinel + wake the agent
-                try {
-                    // Use unlinkSync via require to keep top-level import surface tight
-                    // (already imported existsSync — we use it before unlink to be safe)
-                    const sentinelPath = path.join(wakeDir, filename);
-                    if (existsSync(sentinelPath)) {
-                        // best-effort: import unlinkSync inline
-                        // eslint-disable-next-line @typescript-eslint/no-var-requires
-                        const fs = require('node:fs');
-                        try {
-                            fs.unlinkSync(sentinelPath);
-                        }
-                        catch { /* ignore */ }
+                // Consume the sentinel + wake the agent. Best-effort delete so the
+                // same sentinel can't fire repeatedly.
+                const sentinelPath = path.join(wakeDir, filename);
+                if (existsSync(sentinelPath)) {
+                    try {
+                        unlinkSync(sentinelPath);
                     }
+                    catch { /* ignore */ }
                 }
-                catch { /* non-fatal */ }
                 this.scheduleWake(slug, 'wake-sentinel');
             });
         }
@@ -197,9 +190,7 @@ export class AgentHeartbeatManager {
             const triggerPath = path.join(BASE_DIR, 'cron', 'goal-triggers', filename);
             if (!existsSync(triggerPath))
                 return; // file was already consumed by cron-scheduler
-            // eslint-disable-next-line @typescript-eslint/no-var-requires
-            const fs = require('node:fs');
-            const trigger = JSON.parse(fs.readFileSync(triggerPath, 'utf-8'));
+            const trigger = JSON.parse(readFileSync(triggerPath, 'utf-8'));
             if (!trigger.goalId)
                 return;
             const lookup = listAllGoals().find((g) => g.goal && g.goal.id === trigger.goalId);

package/package.json

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