claude-mem-lite 2.44.0 → 2.46.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.44.0",
+      "version": "2.46.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.44.0",
+  "version": "2.46.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/hook-handoff.mjs

@@ -298,7 +298,7 @@ export function detectContinuationIntent(db, promptText, project, currentCcSessi
  * @param {string|null} [currentCcSessionId=null] Claude Code session id for scoping
  * @returns {string|null} Injection text or null if no handoff
  */
-export function renderHandoffInjection(db, project, currentCcSessionId = null) {
+export function pickHandoffToInject(db, project, currentCcSessionId = null) {
   const now = Date.now();
   // Fetch recent handoffs and find the most recent non-expired one.
   // A newer but expired 'clear' handoff must not shadow a still-valid 'exit' handoff.
@@ -313,13 +313,20 @@ export function renderHandoffInjection(db, project, currentCcSessionId = null) {
         SELECT * FROM session_handoffs
         WHERE project = ? ORDER BY created_at_epoch DESC LIMIT 5
       `).all(project);
-  const handoff = handoffs.find(h => {
+  return handoffs.find(h => {
     const age = now - h.created_at_epoch;
     const maxAge = h.type === 'clear' ? HANDOFF_EXPIRY_CLEAR : HANDOFF_EXPIRY_EXIT;
     return age <= maxAge;
-  });
+  }) || null;
+}
+
+export function renderHandoffInjection(db, project, currentCcSessionId = null) {
+  const handoff = pickHandoffToInject(db, project, currentCcSessionId);
   if (!handoff) return null;
+  return renderHandoffFromRow(handoff, db, project);
+}
 
+function renderHandoffFromRow(handoff, db, project) {
   const ageSec = Math.round((Date.now() - handoff.created_at_epoch) / 1000);
   const ageStr = ageSec < 60 ? `${ageSec}s` :
     ageSec < 3600 ? `${Math.round(ageSec / 60)}m` :

package/hook-llm.mjs

@@ -431,15 +431,30 @@ export function buildImmediateObservation(episode) {
   }
 
   const ruleImportance = computeRuleImportance(episode);
-  // Low-signal degraded titles ("Error in...", "Modified...") should not inflate importance.
-  // Cap at 1 unless rule-based signals indicate genuine importance (error-in-test → 3, config → 2).
+  // Low-signal degraded titles ("Modified X", "Worked on X", "Reviewed N files")
+  // should not inflate importance. computeRuleImportance's file-name heuristics
+  // (schema.*, migration, auth.*, .env, .pem) fire on any matching file in the
+  // episode, so a 5-file review that incidentally reads one schema.js triggers
+  // imp=3 even though schema.js was one of 5 scanned — not the focus. Combined
+  // with a LOW_SIGNAL title (Haiku couldn't extract meaning), we can't justify
+  // imp=3; cap at 2 so rule says "notable" but not "critical".
+  //
+  // Production baseline (2026-04-23, projects--mem): 34/100 discovery/imp=3
+  // obs were LOW_SIGNAL titles; 7 change/imp=3 same. Prior cap `rule<=2 → 1`
+  // only fired when rule was weak, letting rule=3 leak through. New cap:
+  //   isReviewPattern → 2 (was Math.max(2, rule) → rule=3 leaked as 3)
+  //   isLowSignal & !review:
+  //     rule=3 → 2 (was 3)             — the fix
+  //     rule<=2 → 1 (unchanged)        — original cap preserved
   const LOW_SIGNAL = LOW_SIGNAL_TITLE;
   const isLowSignal = LOW_SIGNAL.test(title);
   let importance;
   if (isReviewPattern) {
-    importance = Math.max(2, ruleImportance);
-  } else if (isLowSignal && ruleImportance <= 2) {
-    importance = 1; // Degraded titles stay low unless rule signals critical (imp=3)
+    // Review titles are auto-generated from file count — can't distinguish
+    // "critical file was primary focus" from "one of N files read". Cap at 2.
+    importance = 2;
+  } else if (isLowSignal) {
+    importance = ruleImportance === 3 ? 2 : 1;
   } else {
     importance = ruleImportance;
   }
@@ -838,10 +853,24 @@ key_decisions: Only decisions with lasting impact (library choices, architecture
       `).get(sessionId);
 
       if (existingFast) {
+        // Preserve structural-extractor content (completed / remaining_items written
+        // by handleStop fast-baseline from CLAUDE.md §10 markers) when Haiku returns
+        // empty for that field. Without COALESCE, a degraded Haiku pass would erase
+        // the deterministic floor — the exact regression that made 72% of prod
+        // session_summaries ship with empty remaining_items.
         db.prepare(`
           UPDATE session_summaries
-          SET request=?, investigated=?, learned=?, completed=?, next_steps=?, remaining_items=?,
-              lessons=?, key_decisions=?, notes='llm', created_at=?, created_at_epoch=?
+          SET request = COALESCE(NULLIF(?, ''), request),
+              investigated = COALESCE(NULLIF(?, ''), investigated),
+              learned = COALESCE(NULLIF(?, ''), learned),
+              completed = COALESCE(NULLIF(?, ''), completed),
+              next_steps = COALESCE(NULLIF(?, ''), next_steps),
+              remaining_items = COALESCE(NULLIF(?, ''), remaining_items),
+              lessons = COALESCE(?, lessons),
+              key_decisions = COALESCE(?, key_decisions),
+              notes = 'llm',
+              created_at = ?,
+              created_at_epoch = ?
           WHERE id = ?
         `).run(
           llmParsed.request || '', llmParsed.investigated || '', llmParsed.learned || '',

package/hook.mjs

@@ -43,8 +43,9 @@ import {
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
 import { extractCitationsFromTranscript, bumpCitationAccess } from './lib/citation-tracker.mjs';
+import { extractTailAssistantText, extractStructuredSummary } from './lib/summary-extractor.mjs';
 import { searchRelevantMemories } from './hook-memory.mjs';
-import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, extractUnfinishedSummary } from './hook-handoff.mjs';
+import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, pickHandoffToInject, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate } from './hook-update.mjs';
 import { handleLLMOptimize } from './hook-optimize.mjs';
 import { silentAutoAdopt, hasAutoAdoptMarker } from './adopt-cli.mjs';
@@ -442,14 +443,46 @@ async function handleStop() {
             ORDER BY created_at_epoch DESC LIMIT 5
           `).all(sessionId);
           const fastRequest = truncate(firstPrompt?.prompt_text || '', 200);
-          const fastCompleted = recentObs.map(o => o.title).filter(Boolean).join('; ');
-          if (fastRequest || fastCompleted) {
+          const obsCompleted = recentObs.map(o => o.title).filter(Boolean).join('; ');
+
+          // Structural extraction from the assistant's tail message.
+          // CLAUDE.md §10 mandates Done/Not done/Failed/Uncertain markers, so the
+          // tail is deterministically parseable without Haiku. Prior baseline left
+          // remaining_items=='' for every session whose Haiku pass failed (≈66%
+          // in prod data), losing the user-visible "Not done" list.
+          let structuredCompleted = '';
+          let structuredNotDone = '';
+          let structuredNotes = '';
+          try {
+            const tail = transcriptPath ? extractTailAssistantText(transcriptPath) : null;
+            if (tail) {
+              const s = extractStructuredSummary(tail);
+              structuredCompleted = s.done;
+              structuredNotDone = s.notDone;
+              const notesParts = [];
+              if (s.failed) notesParts.push(`Failed: ${s.failed}`);
+              if (s.uncertain) notesParts.push(`Uncertain: ${s.uncertain}`);
+              structuredNotes = notesParts.join('\n');
+            }
+          } catch (e) { debugCatch(e, 'handleStop-structured-extract'); }
+
+          const finalCompleted = structuredCompleted || obsCompleted;
+          const finalRemaining = structuredNotDone;
+          const finalNotes = structuredNotes || 'fast';
+
+          if (fastRequest || finalCompleted || finalRemaining) {
             const now = new Date();
             db.prepare(`
               INSERT INTO session_summaries
               (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
-              VALUES (?, ?, ?, '', '', ?, '', '', '[]', '[]', 'fast', ?, ?)
-            `).run(sessionId, project, fastRequest, truncate(fastCompleted, 300), now.toISOString(), now.getTime());
+              VALUES (?, ?, ?, '', '', ?, '', ?, '[]', '[]', ?, ?, ?)
+            `).run(
+              sessionId, project, fastRequest,
+              truncate(finalCompleted, 600),
+              truncate(finalRemaining, 600),
+              truncate(finalNotes, 400),
+              now.toISOString(), now.getTime()
+            );
           }
         }
       } catch (e) { debugCatch(e, 'handleStop-fast-summary'); }
@@ -963,19 +996,19 @@ async function handleUserPrompt() {
     if (promptNumber <= 3) {
       try {
         if (detectContinuationIntent(db, promptText, project, ccSessionId)) {
-          const injection = renderHandoffInjection(db, project, ccSessionId);
-          if (injection) {
-            process.stdout.write(injection + '\n');
-            // Consume handoff after injection to prevent re-injection on later prompts
-            // (within-session on prompts 2-3, or across new sessions for exit handoffs).
-            // clear: scoped to THIS session (parallel sessions keep their own rows).
-            // exit:  unscoped — any exit handoff in this project is fair game once resumed.
+          const picked = pickHandoffToInject(db, project, ccSessionId);
+          if (picked) {
+            const injection = renderHandoffInjection(db, project, ccSessionId);
+            if (injection) process.stdout.write(injection + '\n');
+            // Consume ONLY the row we just injected — leave other projects' exit
+            // handoffs intact so future sessions can still resume from them.
+            // Pre-v2.46 wiped every exit handoff for the project on any continuation
+            // intent, which made the DB effectively forgetful: 115 completed sessions
+            // produced 1 persisted handoff.
             try {
-              if (ccSessionId) {
-                db.prepare("DELETE FROM session_handoffs WHERE project = ? AND ((type = 'clear' AND session_id = ?) OR type = 'exit')").run(project, ccSessionId);
-              } else {
-                db.prepare("DELETE FROM session_handoffs WHERE project = ? AND type IN ('clear','exit')").run(project);
-              }
+              db.prepare(
+                'DELETE FROM session_handoffs WHERE project = ? AND type = ? AND session_id = ?'
+              ).run(project, picked.type, picked.session_id);
             } catch {}
           }
         }

package/lib/summary-extractor.mjs

@@ -0,0 +1,112 @@
+// Structured summary extractor: reads the tail assistant message from a
+// Claude Code transcript and pulls out Done / Not done / Failed / Uncertain
+// sections using deterministic markers. This is the non-Haiku path — the
+// markers are enforced by CLAUDE.md §10's four-section order rule, so they
+// appear in ~every end-of-task message.
+//
+// Haiku summarization remains the richer best-effort enrichment, but it
+// silently fails ~66% of Stop events in practice, leaving session_summaries
+// with empty remaining_items. This extractor runs synchronously in
+// handleStop and gives a deterministic floor.
+
+import { readFileSync, existsSync } from 'fs';
+
+const EN_HEADER = /^[\s●*>-]*(Done|Not\s+done|Failed|Uncertain)\s*[:：]\s*/im;
+const ZH_HEADER = /^[\s●*>-]*(剩下的?|剩余|还剩|未完成|下次(?:要做|做|继续)?|待做|未做)\s*[:：]?\s*/m;
+
+// Recognised section keys, normalised.
+const EN_KEY = { done: 'done', 'not done': 'notDone', failed: 'failed', uncertain: 'uncertain' };
+const ZH_KEY_IS_NOTDONE = /剩下|剩余|还剩|未完成|下次|待做|未做/;
+
+/**
+ * Read the LAST assistant text block from a Claude Code transcript .jsonl.
+ * Returns concatenated text of all text blocks in the last `type='assistant'`
+ * entry, or null if the file is missing/empty/malformed.
+ *
+ * @param {string} transcriptPath
+ * @returns {string|null}
+ */
+export function extractTailAssistantText(transcriptPath) {
+  if (!transcriptPath || !existsSync(transcriptPath)) return null;
+  let raw;
+  try { raw = readFileSync(transcriptPath, 'utf8'); } catch { return null; }
+  let last = null;
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (entry.type !== 'assistant' || !entry.message) continue;
+    const content = entry.message.content;
+    if (!Array.isArray(content)) continue;
+    const texts = content
+      .filter(b => b && b.type === 'text' && typeof b.text === 'string')
+      .map(b => b.text);
+    if (texts.length === 0) continue;
+    last = texts.join('\n');
+  }
+  return last;
+}
+
+/**
+ * Extract Done / Not done / Failed / Uncertain sections from a message body.
+ * Returns an object with four string fields (empty when the section is absent).
+ *
+ * Strategy: scan line by line, recognise section headers in EN and 中文,
+ * attribute subsequent content to that section until the next header or a
+ * hard boundary (blank line followed by a non-bullet line).
+ *
+ * @param {string} text
+ * @returns {{done: string, notDone: string, failed: string, uncertain: string}}
+ */
+export function extractStructuredSummary(text) {
+  const out = { done: '', notDone: '', failed: '', uncertain: '' };
+  if (!text || typeof text !== 'string') return out;
+
+  const lines = text.split('\n');
+  let current = null;
+  const buffers = { done: [], notDone: [], failed: [], uncertain: [] };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Header detection — EN first (unambiguous), then 中文.
+    const enMatch = line.match(EN_HEADER);
+    if (enMatch) {
+      const key = EN_KEY[enMatch[1].toLowerCase().replace(/\s+/g, ' ')];
+      if (key) {
+        current = key;
+        const tail = line.slice(enMatch[0].length).trim();
+        if (tail) buffers[current].push(tail);
+        continue;
+      }
+    }
+    const zhMatch = line.match(ZH_HEADER);
+    if (zhMatch && ZH_KEY_IS_NOTDONE.test(zhMatch[1])) {
+      current = 'notDone';
+      const tail = line.slice(zhMatch[0].length).trim();
+      if (tail) buffers.notDone.push(tail);
+      continue;
+    }
+
+    if (!current) continue;
+
+    // Paragraph-break termination: blank line followed by a non-bullet,
+    // non-indented line starts a fresh paragraph unrelated to the section.
+    if (!trimmed) {
+      const next = (lines[i + 1] || '').trim();
+      const nextIsBullet = /^[-*•●\d]+[.)]?\s+/.test(next);
+      if (!nextIsBullet && next) {
+        current = null;
+      }
+      continue;
+    }
+
+    buffers[current].push(trimmed);
+  }
+
+  for (const k of Object.keys(buffers)) {
+    out[k] = buffers[k].join('\n').trim();
+  }
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.44.0",
+  "version": "2.46.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -51,6 +51,7 @@
     "lib/stats-quality.mjs",
     "lib/low-signal-patterns.mjs",
     "lib/citation-tracker.mjs",
+    "lib/summary-extractor.mjs",
     "lib/id-routing.mjs",
     "lib/err-sampler.mjs",
     "lib/metrics.mjs",

package/source-files.mjs

@@ -38,6 +38,7 @@ export const SOURCE_FILES = [
   'lib/stats-quality.mjs',
   'lib/low-signal-patterns.mjs',
   'lib/citation-tracker.mjs',
+  'lib/summary-extractor.mjs',
   'lib/id-routing.mjs',
   'lib/err-sampler.mjs',
   'lib/metrics.mjs',