claude-mem-lite 2.2.0 → 2.2.2

package/dispatch-feedback.mjs

@@ -183,13 +183,12 @@ export async function collectFeedback(db, sessionId, sessionEvents = []) {
     const invocations = getSessionInvocations(db, sessionId);
     if (invocations.length === 0) return;
 
-    const outcome = detectOutcome(sessionEvents);
-
     for (const inv of invocations) {
       // Skip if already collected (prevents double-collection from stop + session-start)
       if (inv.outcome) continue;
 
       const adopted = detectAdoption(inv, sessionEvents);
+      const outcome = adopted ? detectOutcome(sessionEvents) : 'ignored';
       const score = adopted ? (outcome === 'success' ? 1.0 : outcome === 'partial' ? 0.5 : 0.2) : 0;
 
       // Update invocation record

package/dispatch.mjs

@@ -5,17 +5,14 @@
 // Tier 3: Haiku semantic dispatch (~500ms, only when needed)
 
 import { basename, join } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { retrieveResources, buildEnhancedQuery, buildQueryFromText, DISPATCH_SYNONYMS } from './registry-retriever.mjs';
 import { renderInjection } from './dispatch-inject.mjs';
 import { updateResourceStats, recordInvocation } from './registry.mjs';
 import { callHaikuJSON } from './haiku-client.mjs';
 import { debugCatch, truncate } from './utils.mjs';
-import { DB_DIR } from './schema.mjs';
-
-// Duplicated from hook-shared.mjs to avoid circular import (dispatch ← hook ← hook-shared)
-const RUNTIME_DIR = join(DB_DIR, 'runtime');
-try { if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true }); } catch {}
+import { peekToolEvents, RUNTIME_DIR } from './hook-shared.mjs';
+import { detectActiveSuite, shouldRecommendForStage, detectExplicitRequest, inferCurrentStage } from './dispatch-workflow.mjs';
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -28,6 +25,10 @@ const READ_ONLY_TOOLS = new Set([
 export const COOLDOWN_MINUTES = 60;
 export const SESSION_RECOMMEND_CAP = 3;
 
+// Minimum absolute BM25 composite score to recommend. Typical good matches score 5-50;
+// this filters only near-zero noise matches from incidental text overlap.
+export const BM25_MIN_THRESHOLD = 1.5;
+
 // ─── Haiku Circuit Breaker ──────────────────────────────────────────────────
 // Prevents cascading latency when Haiku API is down or slow.
 // After BREAKER_THRESHOLD consecutive failures, disable for BREAKER_RESET_MS.
@@ -691,7 +692,7 @@ function reRankByKeywords(results, rawKeywords) {
  * @param {object[]} results FTS5 results with recommend_count/adopt_count
  * @returns {object[]} Filtered results with decayed scores
  */
-function applyAdoptionDecay(results) {
+function applyAdoptionDecay(results, db) {
   return results.map(r => {
     const recs = r.recommend_count || 0;
     const adopts = r.adopt_count || 0;
@@ -699,14 +700,23 @@ function applyAdoptionDecay(results) {
 
     const rate = (adopts + 1) / (recs + 2); // Laplace smoothing
     let multiplier = 1.0;
-    if (recs > 100 && rate < 0.01) multiplier = 0;       // Block entirely
-    else if (recs > 50 && rate < 0.02) multiplier = 0.1;  // Heavy penalty
-    else if (recs > 20 && rate < 0.05) multiplier = 0.3;  // Light penalty
+    if (recs > 100 && rate < 0.01) multiplier = 0.05;   // Near-block but not permanent
+    else if (recs > 50 && rate < 0.02) multiplier = 0.15;
+    else if (recs > 20 && rate < 0.05) multiplier = 0.4;
+
+    // Recent rejection boost: extra penalty for resources rejected many times recently
+    if (db && multiplier < 1) {
+      try {
+        const recentRejects = db.prepare(
+          `SELECT COUNT(*) as cnt FROM invocations WHERE resource_id = ? AND adopted = 0 AND created_at > datetime('now', '-7 days')`
+        ).get(r.id)?.cnt || 0;
+        if (recentRejects >= 10) multiplier *= 0.3;
+        else if (recentRejects >= 5) multiplier *= 0.5;
+      } catch (e) { debugCatch(e, 'applyAdoptionDecay-recentRejects'); }
+    }
 
-    if (multiplier === 0) return null;
+    if (multiplier < 0.01) return null;
     if (multiplier < 1) {
-      // Composite scores are negative (more negative = more relevant).
-      // To penalize: multiply by multiplier (<1) to make less negative (worse rank).
       return { ...r, composite_score: (r.composite_score ?? r.relevance) * multiplier, _decayed: true };
     }
     return r;
@@ -722,6 +732,15 @@ function applyAdoptionDecay(results) {
  * @returns {object[]} Filtered results that pass the gate
  */
 function passesConfidenceGate(results, signals) {
+  // BM25 absolute minimum: filter out weak text matches regardless of intent.
+  // Only apply when enough results exist (BM25 IDF is unreliable with < 3 matches).
+  if (results.length >= 3) {
+    results = results.filter(r => {
+      const score = Math.abs(r.composite_score ?? r.relevance);
+      return score >= BM25_MIN_THRESHOLD;
+    });
+  }
+
   // signals.intent is a comma-separated string (e.g. "test,fix"), not an array
   const intentTokens = typeof signals?.intent === 'string'
     ? signals.intent.split(',').filter(Boolean)
@@ -748,13 +767,19 @@ function passesConfidenceGate(results, signals) {
 
 /**
  * Dispatch on SessionStart: analyze user prompt, return best resource suggestion.
+ * Only dispatches when continuing from a previous session (handoff).
+ * Cold starts (no previous session) showed 0% adoption — skip dispatch entirely.
  * @param {Database} db Registry database
  * @param {string} userPrompt User's prompt text
  * @param {string} [sessionId] Session identifier for dedup
+ * @param {Object} [options]
+ * @param {boolean} [options.hasHandoff=false] Whether a previous session handoff exists
  * @returns {Promise<string|null>} Injection text or null
  */
-export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
-  if (!userPrompt || !db) return null;
+export async function dispatchOnSessionStart(db, userPrompt, sessionId, { hasHandoff = false } = {}) {
+  if (!db) return null;
+  if (!hasHandoff) return null;  // Only dispatch when continuing from a previous session
+  if (!userPrompt) return null;  // Prompt still required for FTS query
 
   try {
     const projectDomains = detectProjectDomains();
@@ -783,7 +808,7 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
     }
 
     results = reRankByKeywords(results, signals.rawKeywords);
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     results = results.slice(0, 3);
 
@@ -804,7 +829,7 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
           if (haikuResults.length > 0) {
             // Apply same post-processing as Tier2 to prevent zombie/low-confidence bypass
             haikuResults = reRankByKeywords(haikuResults, signals.rawKeywords);
-            haikuResults = applyAdoptionDecay(haikuResults);
+            haikuResults = applyAdoptionDecay(haikuResults, db);
             haikuResults = passesConfidenceGate(haikuResults, signals);
             if (haikuResults.length > 0) results = haikuResults;
           }
@@ -848,14 +873,46 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
  * @param {string} [sessionId] Session identifier for dedup
  * @returns {Promise<string|null>} Injection text or null
  */
-export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
+export async function dispatchOnUserPrompt(db, userPrompt, sessionId, { sessionEvents } = {}) {
   if (!userPrompt || !db) return null;
 
   try {
+    // 1. Explicit request → highest priority, bypass all restrictions
+    const explicit = detectExplicitRequest(userPrompt);
+    if (explicit.isExplicit) {
+      const textQuery = buildQueryFromText(explicit.searchTerm);
+      if (textQuery) {
+        const explicitResults = retrieveResources(db, textQuery, { limit: 3, projectDomains: detectProjectDomains() });
+        if (explicitResults.length > 0) {
+          const best = explicitResults[0];
+          if (!sessionId || !isRecentlyRecommended(db, best.id, sessionId)) {
+            recordInvocation(db, { resource_id: best.id, session_id: sessionId, trigger: 'user_prompt', tier: 1, recommended: 1 });
+            updateResourceStats(db, best.id, 'recommend_count');
+            return renderInjection(best);
+          }
+        }
+      }
+    }
+
+    // 2. Suite auto-flow protection
+    const events = sessionEvents || peekToolEvents();
+    const activeSuite = detectActiveSuite(events);
+
     const projectDomains = detectProjectDomains();
 
     // Intent-aware enhanced query (column-targeted)
     const signals = extractContextSignals({ tool_name: '_user_prompt' }, { userPrompt });
+
+    // Check if active suite covers the current stage
+    if (activeSuite) {
+      const currentStage = inferCurrentStage(signals.primaryIntent, activeSuite);
+      if (currentStage) {
+        const { shouldRecommend } = shouldRecommendForStage(activeSuite, currentStage);
+        if (!shouldRecommend) return null;
+      }
+    }
+
+    // 3. Normal FTS flow
     const enhancedQuery = buildEnhancedQuery(signals);
 
     // Fetch extra results when rawKeywords are present — the top-3 by BM25 may be
@@ -882,21 +939,14 @@ export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
     // match those keywords. "帮我做一下SEO审查" → rawKeywords=["seo"] → SEO audit
     // resources should rank above generic code-review resources.
     results = reRankByKeywords(results, signals.rawKeywords);
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     results = results.slice(0, 3);
 
     if (results.length === 0) return null;
 
-    // Skip if low confidence (no Haiku fallback — stay fast).
-    // Exception: when results match the user's raw domain keywords (e.g. "seo"),
-    // close BM25 scores indicate "multiple equally good options in the right domain"
-    // rather than "ambiguous/wrong match". Trust the domain match.
-    if (needsHaikuDispatch(results)) {
-      const hasKeywordMatch = signals.rawKeywords?.length > 0 && results.some(r =>
-        signals.rawKeywords.some(kw => (r.intent_tags || '').toLowerCase().includes(kw)));
-      if (!hasKeywordMatch) return null;
-    }
+    // Low confidence → skip (no Haiku in user_prompt path — stay fast)
+    if (needsHaikuDispatch(results)) return null;
 
     // Filter by cooldown + session dedup (prevents double-recommend with SessionStart)
     const viable = sessionId
@@ -939,6 +989,18 @@ export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
 
     // Tier 1: Extract context signals
     const signals = extractContextSignals(event, sessionCtx);
+
+    // Suite protection: if a suite auto-flow is active, suppress recommendations
+    // for stages the suite already covers
+    const events = peekToolEvents();
+    const activeSuite = detectActiveSuite(events);
+    if (activeSuite) {
+      const stage = inferCurrentStage(signals.primaryIntent, activeSuite);
+      if (stage) {
+        const { shouldRecommend } = shouldRecommendForStage(activeSuite, stage);
+        if (!shouldRecommend) return null;
+      }
+    }
     const query = buildEnhancedQuery(signals);
     if (!query) return null;
 
@@ -946,7 +1008,7 @@ export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
 
     // Tier 2: FTS5 retrieval
     let results = retrieveResources(db, query, { limit: 3, projectDomains });
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     if (results.length === 0) return null;
 

package/hook-episode.mjs

@@ -216,13 +216,23 @@ export function mergePendingEntries(episode) {
  * @returns {boolean} true if the episode has significant content
  */
 export function episodeHasSignificantContent(episode) {
+  // 1. File edits or Bash errors → always significant
   const hasEditsOrErrors = episode.entries.some(e =>
     EDIT_TOOLS.has(e.tool) ||
     (e.tool === 'Bash' && e.isError)
   );
   if (hasEditsOrErrors) return true;
 
-  // Review/research pattern: reading many files indicates investigation
+  // 2. Important files touched (config, schema, security, migration)
+  // Checks episode.files (all touched files, including reads) — catches important-file investigation
+  const allFiles = episode.files || [];
+  const hasImportantFile = allFiles.some(f =>
+    /\.(env|yml|yaml|toml|lock|sql|prisma|proto)$/.test(f) ||
+    /(config|schema|migration|auth|security)/i.test(f)
+  );
+  if (hasImportantFile) return true;
+
+  // 3. Research pattern: reading many files indicates investigation
   const readCount = episode.entries.filter(e =>
     e.tool === 'Read' || e.tool === 'Grep'
   ).length;

package/hook-llm.mjs

@@ -267,7 +267,7 @@ Error: ${e.isError ? 'yes' : 'no'}
 
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1}
 Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
-importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
+importance: 0=not worth saving (pure browsing, trivial query, no learning value), 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
   } else {
     const actionList = episode.entries.map((e, i) =>
       `${i + 1}. [${e.tool}] ${e.desc}${e.isError ? ' (ERROR)' : ''}`
@@ -282,7 +282,7 @@ ${actionList}
 
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"coherent ≤80 char summary","narrative":"what was done, why, and outcome (3-5 sentences)","concepts":["keyword1","keyword2"],"facts":["specific fact 1","specific fact 2"],"importance":1}
 Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
-importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
+importance: 0=not worth saving (pure browsing, trivial query, no learning value), 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
   }
 
   const ruleImportance = computeRuleImportance(episode);
@@ -301,6 +301,21 @@ importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=cr
     }
 
     if (parsed && parsed.title) {
+      // Discard if LLM judges observation has no learning value
+      if (parsed.importance === 0 || parsed.importance === '0') {
+        debugLog('DEBUG', 'llm-episode', `Discarded low-value observation: ${parsed.title}`);
+        // If pre-saved, delete it too
+        if (episode.savedId) {
+          const ddb = openDb();
+          if (ddb) {
+            try { ddb.prepare('DELETE FROM observations WHERE id = ?').run(episode.savedId); }
+            finally { ddb.close(); }
+          }
+        }
+        try { unlinkSync(tmpFile); } catch {}
+        return;
+      }
+
       obs = {
         type: validTypes.has(parsed.type) ? parsed.type : 'change',
         title: truncate(parsed.title, 120),

package/hook-shared.mjs

@@ -179,6 +179,20 @@ export function readAndClearToolEvents() {
   }
 }
 
+/**
+ * Read tracked tool events WITHOUT clearing the file.
+ * Used by dispatch to detect active suites mid-session.
+ * @returns {object[]} Array of tool event objects
+ */
+export function peekToolEvents() {
+  try {
+    const raw = readFileSync(toolEventsFile(), 'utf8');
+    return raw.trim().split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
 /**
  * Extract partial response from CLI error output (timeout/error recovery).
  * @param {Error} error The caught error from execFileSync

package/hook.mjs

@@ -369,9 +369,12 @@ async function handleStop() {
   // Always clear event file to prevent stale events accumulating if registry DB is unavailable.
   try {
     const sessionEvents = readAndClearToolEvents();
-    const rdb = getRegistryDb();
-    if (rdb) {
-      await collectFeedback(rdb, sessionId, sessionEvents);
+    // Skip feedback for zero-interaction sessions (no tool events = no meaningful signal)
+    if (sessionEvents.length > 0) {
+      const rdb = getRegistryDb();
+      if (rdb) {
+        await collectFeedback(rdb, sessionId, sessionEvents);
+      }
     }
   } catch (e) { debugCatch(e, 'handleStop-feedback'); }
 
@@ -428,7 +431,7 @@ async function handleSessionStart() {
 
     // ── DB mutations in a transaction (crash-safe consistency) ──
     const staleSessionCutoff = Date.now() - STALE_SESSION_MS;
-    const autoCompressAge = Date.now() - 90 * 86400000; // 90 days
+    const autoCompressAge = Date.now() - 30 * 86400000; // 30 days (accelerated from 90)
 
     db.transaction(() => {
       // Ensure session exists in DB (INSERT OR IGNORE avoids race condition)
@@ -451,7 +454,7 @@ async function handleSessionStart() {
         WHERE status = 'active' AND started_at_epoch < ?
       `).run(staleSessionCutoff);
 
-      // Auto-compress: mark old low-importance observations as compressed (90+ days, importance=1)
+      // Auto-compress: mark old low-importance observations as compressed (30+ days, importance=1)
       // Lightweight: only marks rows, doesn't create summaries (full compression via mem_compress)
       const compressed = db.prepare(`
         UPDATE observations SET compressed_into = -1
@@ -675,8 +678,10 @@ async function handleSessionStart() {
     try {
       const rdb = getRegistryDb();
       if (rdb && hasInjectionBudget()) {
-        const promptCtx = latestSummary?.next_steps || '';
-        const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId);
+        // Build prompt context with fallbacks: next_steps → request → completed (empty = no dispatch)
+        const promptCtx = latestSummary?.next_steps || latestSummary?.request || latestSummary?.completed || '';
+        const hasHandoff = !!prevSessionId;  // prevSessionId set when /clear or rapid restart detected
+        const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId, { hasHandoff });
         if (dispatchResult) {
           process.stdout.write(dispatchResult + '\n');
           incrementInjection();

package/install.mjs

@@ -1217,7 +1217,7 @@ async function install() {
     'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
     'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
     'registry-retriever.mjs', 'resource-discovery.mjs',
-    'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs',
+    'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-workflow.mjs',
   ];
 
   if (IS_DEV) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/registry.mjs

@@ -104,7 +104,7 @@ const INVOCATIONS_SCHEMA = `
     tier          INTEGER CHECK(tier IN (1,2,3)),
     recommended   INTEGER DEFAULT 1,
     adopted       INTEGER DEFAULT 0,
-    outcome       TEXT CHECK(outcome IN ('success','partial','failure','skipped',NULL)),
+    outcome       TEXT CHECK(outcome IN ('success','partial','failure','skipped','ignored',NULL)),
     score         REAL,
     created_at    TEXT DEFAULT (datetime('now'))
   );
@@ -192,6 +192,24 @@ export function ensureRegistryDb(dbPath) {
     }
   } catch (e) { debugCatch(e, 'ensureRegistryDb-migration'); }
 
+  // Migrate invocations CHECK constraint: add 'ignored' outcome value
+  try {
+    const schema = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='invocations'`).get();
+    if (schema?.sql && !schema.sql.includes("'ignored'")) {
+      db.transaction(() => {
+        const hasOld = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='invocations_old'`).get();
+        if (hasOld) db.exec(`DROP TABLE invocations_old`);
+        db.exec(`ALTER TABLE invocations RENAME TO invocations_old`);
+        db.exec(INVOCATIONS_SCHEMA);
+        db.exec(`INSERT INTO invocations
+          (id, resource_id, session_id, trigger, tier, recommended, adopted, outcome, score, created_at)
+          SELECT id, resource_id, session_id, trigger, tier, recommended, adopted, outcome, score, created_at
+          FROM invocations_old`);
+        db.exec(`DROP TABLE invocations_old`);
+      })();
+    }
+  } catch (e) { debugCatch(e, 'ensureRegistryDb-ignored-migration'); }
+
   db.exec(PREINSTALLED_SCHEMA);
 
   return db;

package/server.mjs

@@ -61,7 +61,7 @@ const RECENCY_HALF_LIFE_MS = 1209600000; // 14 days in milliseconds
 // ─── MCP Server ─────────────────────────────────────────────────────────────
 
 const server = new McpServer(
-  { name: 'claude-mem-lite', version: '2.1.6' },
+  { name: 'claude-mem-lite', version: '2.2.2' },
   {
     instructions: [
       'Proactively search memory to leverage past experience. This is your long-term memory across sessions.',
@@ -83,9 +83,15 @@ const server = new McpServer(
   },
 );
 
+// Track MCP request activity for idle-time cleanup (see idle timer below)
+let lastMcpRequestTime = Date.now();
+let idleCleanupRan = false;
+
 function safeHandler(fn) {
   return async (args, extra) => {
     try {
+      lastMcpRequestTime = Date.now();
+      idleCleanupRan = false;
       return await fn(args, extra);
     } catch (err) {
       return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
@@ -980,10 +986,58 @@ const walTimer = setInterval(() => {
 }, WAL_CHECKPOINT_INTERVAL);
 walTimer.unref(); // Don't keep process alive just for checkpoints
 
+// ─── Idle-Time Memory Optimization ──────────────────────────────────────────
+// When no MCP requests for 5 minutes, run lightweight DB maintenance.
+// lastMcpRequestTime and idleCleanupRan are declared near safeHandler (which updates them).
+
+const IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+
+const idleTimer = setInterval(() => {
+  if (idleCleanupRan) return;
+  if (Date.now() - lastMcpRequestTime < IDLE_THRESHOLD_MS) return;
+  idleCleanupRan = true;
+
+  try {
+    const thirtyDaysAgo = Date.now() - 30 * 86400000;
+
+    db.transaction(() => {
+      // Delete old low-quality observations (importance<=1, never accessed, 30+ days)
+      const deleted = db.prepare(`
+        DELETE FROM observations
+        WHERE importance <= 1 AND COALESCE(access_count, 0) = 0
+          AND created_at_epoch < ? AND COALESCE(compressed_into, 0) = 0
+      `).run(thirtyDaysAgo);
+      if (deleted.changes > 0) {
+        debugLog('INFO', 'idle-cleanup', `Deleted ${deleted.changes} stale low-quality observations`);
+      }
+
+      // Mark old importance=1 as compressed (30+ days)
+      // NOTE: compressed_into = -1 is an established sentinel meaning "auto-compressed without merge target"
+      // (same pattern used in hook.mjs:456 for time-based compression)
+      const compressed = db.prepare(`
+        UPDATE observations SET compressed_into = -1
+        WHERE COALESCE(compressed_into, 0) = 0 AND importance = 1
+          AND created_at_epoch < ?
+      `).run(thirtyDaysAgo);
+      if (compressed.changes > 0) {
+        debugLog('INFO', 'idle-cleanup', `Compressed ${compressed.changes} old observations`);
+      }
+    })();
+
+    // FTS5 index optimization (outside transaction — WAL-friendly)
+    db.exec("INSERT INTO observations_fts(observations_fts) VALUES('optimize')");
+    debugLog('DEBUG', 'idle-cleanup', 'FTS5 optimize complete');
+  } catch (e) {
+    debugCatch(e, 'idle-cleanup');
+  }
+}, 60000); // Check every minute
+idleTimer.unref();
+
 // ─── Shutdown Cleanup ────────────────────────────────────────────────────────
 
 function shutdown(exitCode = 0) {
   clearInterval(walTimer);
+  clearInterval(idleTimer);
   try { db.pragma('wal_checkpoint(TRUNCATE)'); } catch {}
   try { db.close(); } catch {}
   process.exit(exitCode);