clementine-agent 1.0.23 → 1.0.24

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

@@ -43,7 +43,7 @@ export interface RouteDecision {
  * - `slack:agent:*`, `slack:channel:*:{slug}:*`
  * - `team:*` — inter-agent messages travel via team-bus, never route
  */
-export declare function isRoutable(sessionKey: string, ownerAgentSlugs: Set<string>): boolean;
+export declare function isRoutable(sessionKey: string, _ownerAgentSlugs: Set<string>): boolean;
 /**
  * Classify a user message. Returns null if the call fails — caller
  * should fall back to Clementine handling.

package/dist/agent/route-classifier.js

@@ -38,31 +38,37 @@ const logger = pino({ name: 'clementine.route-classifier' });
  * - `slack:agent:*`, `slack:channel:*:{slug}:*`
  * - `team:*` — inter-agent messages travel via team-bus, never route
  */
-export function isRoutable(sessionKey, ownerAgentSlugs) {
+export function isRoutable(sessionKey, _ownerAgentSlugs) {
     if (!sessionKey)
         return false;
     const parts = sessionKey.split(':');
+    // Structural rule: any 5+ part channel key has an agent slug embedded
+    // (e.g. `discord:channel:{channelId}:{slug}:{userId}`). We reject this
+    // regardless of whether the slug appears in a passed-in roster — the
+    // ownerAgentSlugs list can be stale during agent-hire/rename events,
+    // and the key SHAPE is the safer source of truth.
+    //
+    // `_ownerAgentSlugs` is kept in the signature for future use but the
+    // current implementation is structure-only.
     // Agent-bot DMs and member sessions are always agent-scoped
     if (parts[0] === 'discord') {
         const kind = parts[1];
         if (kind === 'agent' || kind === 'member' || kind === 'member-dm')
             return false;
-        // 5-part discord:channel:{channelId}:{slug}:{userId} means agent in team chat
-        if (kind === 'channel' && parts.length >= 5 && ownerAgentSlugs.has(parts[3] ?? '')) {
+        // Any 5+ part channel key → agent-scoped, never route
+        if (kind === 'channel' && parts.length >= 5)
             return false;
-        }
         // discord:user:* and the 4-part discord:channel:{channelId}:{userId} pass
-        return kind === 'user' || kind === 'channel';
+        return kind === 'user' || (kind === 'channel' && parts.length === 4);
     }
     if (parts[0] === 'slack') {
         const kind = parts[1];
         if (kind === 'agent')
             return false;
-        // slack:channel:{channelId}:{slug}:{userId} — agent-scoped
-        if (kind === 'channel' && parts.length >= 5 && ownerAgentSlugs.has(parts[3] ?? '')) {
+        // Any 5+ part channel key → agent-scoped
+        if (kind === 'channel' && parts.length >= 5)
             return false;
-        }
-        return kind === 'user' || kind === 'dm' || kind === 'channel';
+        return kind === 'user' || kind === 'dm' || (kind === 'channel' && parts.length === 4);
     }
     if (parts[0] === 'telegram')
         return parts[1] === 'user' || /^\d+$/.test(parts[1] ?? '');

package/dist/gateway/claim-tracker.js

@@ -123,13 +123,24 @@ const PATTERNS = [
  * Bounded to prevent memory growth — oldest entries are evicted.
  */
 const MAX_PENDING_LLM = 20;
+const PENDING_LLM_TTL_MS = 6 * 60 * 60 * 1000; // 6h — after that a claim is stale anyway
 const pendingLLMExtraction = [];
+function pruneExpiredPending(now = Date.now()) {
+    while (pendingLLMExtraction.length > 0) {
+        const oldest = pendingLLMExtraction[0];
+        if (now - oldest.queuedAt <= PENDING_LLM_TTL_MS)
+            break;
+        pendingLLMExtraction.shift();
+    }
+}
 function enqueueForLLM(text, sessionKey, agentSlug) {
+    const now = Date.now();
+    pruneExpiredPending(now);
     // De-dup by text hash within the queue — don't re-enqueue the same DM.
     const hash = sha1(text);
-    if (pendingLLMExtraction.some(e => sha1(e.text) === hash))
+    if (pendingLLMExtraction.some(e => e.hash === hash))
         return;
-    pendingLLMExtraction.push({ text, sessionKey, agentSlug, queuedAt: Date.now() });
+    pendingLLMExtraction.push({ text, hash, sessionKey, agentSlug, queuedAt: now });
     while (pendingLLMExtraction.length > MAX_PENDING_LLM)
         pendingLLMExtraction.shift();
 }
@@ -208,11 +219,16 @@ export function extractClaims(text, sessionKey, agentSlug) {
  * the next sweep.
  */
 export async function drainLLMFallback(gateway, maxPerSweep = 3) {
+    pruneExpiredPending();
     let drained = 0;
-    const batch = pendingLLMExtraction.splice(0, Math.min(maxPerSweep, pendingLLMExtraction.length));
+    // Peek — don't remove yet. We only splice on successful processing so a
+    // transient LLM failure doesn't silently drop the candidate.
+    const batch = pendingLLMExtraction.slice(0, Math.min(maxPerSweep, pendingLLMExtraction.length));
+    const toRemove = new Set();
     for (const item of batch) {
         try {
             const claims = await llmExtractClaims(item.text, gateway);
+            toRemove.add(item.hash); // success (or "no claims" — not worth re-trying)
             if (claims.length === 0)
                 continue;
             const toRecord = claims.map(c => ({
@@ -229,9 +245,18 @@ export async function drainLLMFallback(gateway, maxPerSweep = 3) {
             drained += claims.length;
         }
         catch (err) {
+            // Don't add to toRemove — leave in queue for next sweep. TTL eventually
+            // evicts permanently-failing entries.
             logger.debug({ err }, 'LLM fallback extraction failed for one DM');
         }
     }
+    // Remove successfully-processed entries in one pass
+    if (toRemove.size > 0) {
+        for (let i = pendingLLMExtraction.length - 1; i >= 0; i--) {
+            if (toRemove.has(pendingLLMExtraction[i].hash))
+                pendingLLMExtraction.splice(i, 1);
+        }
+    }
     return drained;
 }
 async function llmExtractClaims(text, gateway) {

package/dist/gateway/failure-diagnostics.js

@@ -52,7 +52,10 @@ function loadCache() {
 function saveCache(cache) {
     try {
         mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
-        writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
+        const tmp = CACHE_FILE + '.tmp';
+        writeFileSync(tmp, JSON.stringify(cache, null, 2));
+        const { renameSync } = require('node:fs');
+        renameSync(tmp, CACHE_FILE);
     }
     catch (err) {
         logger.warn({ err }, 'Failed to persist diagnostic cache');

package/dist/gateway/failure-monitor.js

@@ -50,7 +50,12 @@ function loadState() {
 function saveState(state) {
     try {
         mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-        writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+        // Atomic write — write to temp file then rename. Prevents partial
+        // writes from corrupting the state if the process is killed mid-write.
+        const tmp = STATE_FILE + '.tmp';
+        writeFileSync(tmp, JSON.stringify(state, null, 2));
+        const { renameSync } = require('node:fs');
+        renameSync(tmp, STATE_FILE);
     }
     catch (err) {
         logger.warn({ err }, 'Failed to persist failure-monitor state');

package/dist/gateway/fix-verification.js

@@ -29,7 +29,10 @@ function loadState() {
 function saveState(state) {
     try {
         mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-        writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+        const tmp = STATE_FILE + '.tmp';
+        writeFileSync(tmp, JSON.stringify(state, null, 2));
+        const { renameSync } = require('node:fs');
+        renameSync(tmp, STATE_FILE);
     }
     catch (err) {
         logger.warn({ err }, 'Failed to persist fix-verification state');

package/package.json

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