claude-mem-lite 6.13.4 → 6.13.6

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.13.4",
+      "version": "6.13.6",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.13.4",
+  "version": "6.13.6",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/hook-llm.mjs

@@ -25,6 +25,9 @@ import {
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
 import { BG_LLM_TIMEOUT_MS } from './haiku-client.mjs';
 import { scrubRecord, scrubFilePaths } from './lib/scrub-record.mjs';
+import { mergeModelSummary, summarySuperseded } from './lib/fast-summary.mjs';
+import { recordMetric } from './lib/metrics.mjs';
+import { DB_DIR } from './schema.mjs';
 import {
   insertObservationRow,
   insertObservationFiles,
@@ -561,7 +564,7 @@ function linkRelatedObservations(db, savedId, obs, episode) {
         `
       SELECT id, files_modified FROM observations
       WHERE id != ? AND created_at_epoch > ? AND project = ?
-      ORDER BY created_at_epoch DESC LIMIT 50
+      ORDER BY created_at_epoch DESC, id DESC LIMIT 50
     `,
       )
       .all(newObs.id, Date.now() - RELATED_OBS_WINDOW_MS, episode.project);
@@ -1373,8 +1376,28 @@ export async function handleLLMSummary() {
     );
   }
 
+  // The spawning Stop's epoch (absent for the /clear spawn and pre-upgrade workers). Checked
+  // before the model call and again in the write's transaction, because two workers of one
+  // session can finish out of order (P3-6); the later Stop's worker reads the newer window.
+  const parsedEpoch = Number(process.argv[5]);
+  const spawnEpoch = Number.isFinite(parsedEpoch) && parsedEpoch > 0 ? parsedEpoch : null;
+  // One `summary_worker` metric row per exit (CLAUDE_MEM_METRICS=1), carrying the session and
+  // the Stop epoch so a superseded worker can be paired with its successor's outcome, and how
+  // many model calls a session costs can be counted (D#95). This process runs detached with no
+  // stderr, so nothing else shows it.
+  const metricSession = process.argv[3] || null;
+  let llmMs;
+  const outcome = (name) =>
+    recordMetric(DB_DIR, {
+      event: 'summary_worker',
+      outcome: name,
+      session: metricSession,
+      stopEpoch: spawnEpoch,
+      ...(llmMs === undefined ? {} : { llmMs }),
+    });
+
   const db = openDb();
-  if (!db) return;
+  if (!db) return outcome('no-db');
 
   try {
     const sessionId = process.argv[3] || getSessionId();
@@ -1396,7 +1419,7 @@ export async function handleLLMSummary() {
       )
       .all(sessionId);
 
-    if (recentObs.length < 1) return;
+    if (recentObs.length < 1) return outcome('no-obs');
 
     const obsList = recentObs
       .map(
@@ -1432,12 +1455,18 @@ ${obsList}`;
 
     if (!(await acquireLLMSlot())) {
       debugLog('WARN', 'llm-summary', 'semaphore timeout, skipping summary');
-      return;
+      return outcome('slot-timeout');
     }
 
     let raw, llmParsed;
     try {
+      if (summarySuperseded(db, sessionId, spawnEpoch)) {
+        debugLog('DEBUG', 'llm-summary', 'a later Stop owns this session summary, skipping');
+        return outcome('superseded-before-call');
+      }
+      const callStart = Date.now();
       raw = await callLLM(prompt, BG_LLM_TIMEOUT_MS);
+      llmMs = Date.now() - callStart;
       llmParsed = parseJsonFromLLM(raw);
     } finally {
       releaseLLMSlot();
@@ -1459,8 +1488,8 @@ ${obsList}`;
     // alone dropped the whole INSERT/UPDATE (losing the session's highest-value fields:
     // lessons + key_decisions) whenever Haiku returned an empty request string but a rich
     // `{completed, lessons, key_decisions}` — a common degraded shape. Downstream tolerates an
-    // empty request: INSERT writes '' and the UPDATE COALESCE(NULLIF(?, ''), request) preserves
-    // the prior value. Use asText in the gate so a non-string / empty-array field can't falsely
+    // empty request: INSERT writes '' and the UPDATE keeps the row's own request (or an older row's)
+    // when the reply's is empty. Use asText in the gate so a non-string / empty-array field can't falsely
     // trigger it.
     const hasSummaryContent =
       llmParsed &&
@@ -1481,107 +1510,38 @@ ${obsList}`;
           ? JSON.stringify(llmParsed.key_decisions)
           : null;
 
-      // Upgrade existing fast summary instead of creating a duplicate. With two fast rows
-      // for one session (Stop, then SessionStart's unguarded /clear or /compact path), the LOWEST id is
-      // the Stop row, which carries the structural Done / Not done extract that the COALESCE
-      // floor below preserves. Upgrading the highest id lost that content from Last Session
-      // (v6.13.4 defect review P2-1), so the order is spelled out rather than left to the
-      // index. No order covers every shape: the floor reads only the upgraded row (D#80).
-      const existingFast = db
-        .prepare(
-          `
-        SELECT id FROM session_summaries
-        WHERE memory_session_id = ? AND notes = 'fast'
-        ORDER BY id ASC
-        LIMIT 1
-      `,
-        )
-        .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.
-        //
-        // Scrub LLM-output text fields at the UPDATE boundary. lessons /
-        // key_decisions are JSON.stringify(array<string>); we scrub the JSON
-        // string here to match the sibling INSERT path. scrubSecrets uses
-        // opaque placeholders that preserve JSON structure; element-level
-        // pre-scrub remains safer in principle but would diverge from the
-        // merged INSERT contract.
-        const safe = scrubRecord('session_summaries', {
-          request: asText(llmParsed.request),
-          investigated: asText(llmParsed.investigated),
-          learned: asText(llmParsed.learned),
-          completed: asText(llmParsed.completed),
-          next_steps: asText(llmParsed.next_steps),
-          remaining_items: asText(llmParsed.remaining_items),
-          lessons: lessonsJson,
-          key_decisions: decisionsJson,
-        });
-        db.prepare(
-          `
-          UPDATE session_summaries
-          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(
-          safe.request,
-          safe.investigated,
-          safe.learned,
-          safe.completed,
-          safe.next_steps,
-          safe.remaining_items,
-          safe.lessons,
-          safe.key_decisions,
-          now.toISOString(),
-          now.getTime(),
-          existingFast.id,
-        );
+      // Upgrade the session's summary row instead of creating another. This worker runs after
+      // EVERY Stop (one per assistant turn) and again from SessionStart's /clear path; selecting
+      // only a `notes = 'fast'` row found nothing once the first run had upgraded it, and each
+      // later turn INSERTed (one live session: 37 rows in 65 minutes). mergeModelSummary lands
+      // on the session's newest row and keeps a report's Done / Not done over the model's
+      // (lib/fast-summary.mjs).
+      //
+      // Scrub LLM-output text fields at the write boundary. lessons / key_decisions are
+      // JSON.stringify(array<string>); scrubSecrets uses opaque placeholders that preserve
+      // JSON structure, so the JSON string is scrubbed whole.
+      const safe = scrubRecord('session_summaries', {
+        request: asText(llmParsed.request),
+        investigated: asText(llmParsed.investigated),
+        learned: asText(llmParsed.learned),
+        completed: asText(llmParsed.completed),
+        next_steps: asText(llmParsed.next_steps),
+        remaining_items: asText(llmParsed.remaining_items),
+        lessons: lessonsJson,
+        key_decisions: decisionsJson,
+      });
+      if (mergeModelSummary(db, { sessionId, project, fields: safe, now, spawnEpoch })) {
+        outcome('written');
       } else {
-        const safe = scrubRecord('session_summaries', {
-          request: asText(llmParsed.request),
-          investigated: asText(llmParsed.investigated),
-          learned: asText(llmParsed.learned),
-          completed: asText(llmParsed.completed),
-          next_steps: asText(llmParsed.next_steps),
-          remaining_items: asText(llmParsed.remaining_items),
-          lessons: lessonsJson,
-          key_decisions: decisionsJson,
-        });
-        db.prepare(
-          `
-          INSERT INTO session_summaries (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, lessons, key_decisions, created_at, created_at_epoch)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', '[]', '', ?, ?, ?, ?)
-        `,
-        ).run(
-          sessionId,
-          project,
-          safe.request,
-          safe.investigated,
-          safe.learned,
-          safe.completed,
-          safe.next_steps,
-          safe.remaining_items,
-          safe.lessons,
-          safe.key_decisions,
-          now.toISOString(),
-          now.getTime(),
-        );
+        debugLog('DEBUG', 'llm-summary', 'a later Stop landed during the model call, reply dropped');
+        outcome('superseded-at-write');
       }
+    } else {
+      outcome('no-content');
     }
+  } catch (e) {
+    outcome('error');
+    throw e;
   } finally {
     db.close();
   }

package/hook.mjs

@@ -88,7 +88,13 @@ import {
   lastDbUnusable,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveEpisodeImmediate } from './hook-llm.mjs';
-import { readFastSummarySource, insertFastSummary, FAST_SUMMARY_LIMITS } from './lib/fast-summary.mjs';
+import {
+  readFastSummarySource,
+  insertFastSummary,
+  writeStopSummary,
+  writeClearSummary,
+  FAST_SUMMARY_LIMITS,
+} from './lib/fast-summary.mjs';
 import { formatHookError } from './lib/native-binding-hint.mjs';
 import { recordHookError } from './lib/hook-telemetry.mjs';
 import { queueHookContext, queueHookSystemMessage, flushHookStdout } from './lib/hook-stdout.mjs';
@@ -1069,13 +1075,20 @@ function flushEpisodeAtStop(sessionId, project) {
  * parallel-safe row identity). Without the split, CC UUID-based queries miss
  * user_prompts and the handoff row is silently skipped (see hook-handoff.mjs).
  */
-function markSessionCompletedAndSaveHandoff(db, { sessionId, project, ccSessionId, episodeSnapshot }) {
+function markSessionCompletedAndSaveHandoff(
+  db,
+  { sessionId, project, ccSessionId, episodeSnapshot, stopEpoch },
+) {
+  // Every Stop, not only the first: Stop fires per assistant turn, and `status = 'active'` alone
+  // matched the first turn only, so completed_at kept the first turn's end for the whole
+  // session. completed_at_epoch is now the session's LATEST Stop, which the llm-summary worker
+  // compares against its own Stop's epoch to learn that a later worker owns the row (P3-6).
   db.prepare(
     `
     UPDATE sdk_sessions SET status = 'completed', completed_at = ?, completed_at_epoch = ?
-    WHERE content_session_id = ? AND status = 'active'
+    WHERE content_session_id = ? AND status IN ('active', 'completed')
   `,
-  ).run(new Date().toISOString(), Date.now(), sessionId);
+  ).run(new Date(stopEpoch).toISOString(), stopEpoch, sessionId);
   // Save handoff snapshot for cross-session continuity.
   // sessionId = mem-internal (query key); ccSessionId = CC UUID (scope key for
   // parallel-safe row identity). Without the split, CC UUID-based queries miss
@@ -1089,59 +1102,48 @@ function markSessionCompletedAndSaveHandoff(db, { sessionId, project, ccSessionI
 
 /** Fast summary baseline — ensures a summary exists even if the background LLM fails. */
 function writeFastSummaryBaseline(db, { sessionId, project, transcriptPath }) {
-  // Fast summary baseline — ensures summary exists even if background LLM fails.
-  // T4-P2-B: guard against Stop firing twice for the same session (rare but possible;
-  // mirrors handleSessionStart line 795 hasSummary guard). Uses mem-internal sessionId
-  // as the WHERE key per the top-of-file dual-id invariant (#7789).
+  // Stop fires once per assistant TURN and the mem session survives it (R10-P1-1), so this
+  // runs on every turn of a session. The first turn with anything to say INSERTs the row
+  // (T4-P2-B's guard: never a second row); every later turn REFRESHES that row from its tail's
+  // report, or, without one, from the current observation titles where the row's Done is
+  // still titles (lib/fast-summary.mjs writeStopSummary). The guard alone used to stop there, so the
+  // row kept the FIRST turn's report: over 7 days of this machine's transcripts (09:40Z), 20
+  // of the 31 sessions that wrote §10 markers had a first-turn extract different from their
+  // last report. Uses the mem-internal sessionId as the WHERE key per the top-of-file
+  // dual-id invariant (#7789).
   try {
-    const existingSummary = db
-      .prepare('SELECT 1 FROM session_summaries WHERE memory_session_id = ? LIMIT 1')
-      .get(sessionId);
-    if (!existingSummary) {
-      const { request: fastRequestRaw, completed: obsCompleted } = readFastSummarySource(db, sessionId);
-
-      // 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 (fastRequestRaw || finalCompleted || finalRemaining) {
-        insertFastSummary(db, {
-          sessionId,
-          project,
-          now: new Date(),
-          values: {
-            request: fastRequestRaw,
-            completed: finalCompleted,
-            remaining: finalRemaining,
-            notes: finalNotes,
-          },
-          limits: FAST_SUMMARY_LIMITS.stop,
-        });
+    // 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. handleStop calls this
+    // AFTER trackCitationsAtStop so the parse is the one it left memoized.
+    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');
     }
+
+    writeStopSummary(db, {
+      sessionId,
+      project,
+      report: { done: structuredCompleted, notDone: structuredNotDone, lines: structuredNotes },
+      source: readFastSummarySource(db, sessionId),
+      now: new Date(),
+      limits: FAST_SUMMARY_LIMITS.stop,
+    });
   } catch (e) {
     debugCatch(e, 'handleStop-fast-summary');
   }
@@ -1582,13 +1584,18 @@ async function handleStop() {
 
   flushEpisodeAtStop(sessionId, project);
 
-  // Mark session completed + save handoff (sync, instant)
+  // Mark session completed + save handoff (sync, instant). The same epoch goes to the summary
+  // worker below, so it can tell whether a later Stop has superseded it.
+  const stopEpoch = Date.now();
   const db = openDb();
   if (db) {
     try {
-      markSessionCompletedAndSaveHandoff(db, { sessionId, project, ccSessionId, episodeSnapshot });
-      writeFastSummaryBaseline(db, { sessionId, project, transcriptPath });
+      markSessionCompletedAndSaveHandoff(db, { sessionId, project, ccSessionId, episodeSnapshot, stopEpoch });
+      // Citations first: they read the subagent transcripts before the parent, so the parent is
+      // parsed once and stays memoized (D#152). The summary reads the parent's tail on every
+      // turn; run before them, it parsed the parent a second time in any session with subagents.
       trackCitationsAtStop(db, { sessionId, project, ccSessionId, transcriptPath });
+      writeFastSummaryBaseline(db, { sessionId, project, transcriptPath });
     } finally {
       db.close();
     }
@@ -1602,7 +1609,8 @@ async function handleStop() {
   // waits on, then recreates the sandbox tree behind the test's cleanup. Any
   // grace period for that is a race, not a barrier — the post-tag review timed a
   // recreate at 432ms and watched a 300ms grace lose.
-  if (!process.env.CLAUDE_MEM_SKIP_SUMMARY) spawnBackground('llm-summary', sessionId, project);
+  if (!process.env.CLAUDE_MEM_SKIP_SUMMARY)
+    spawnBackground('llm-summary', sessionId, project, String(stopEpoch));
 
   // The session file deliberately SURVIVES Stop (R10-P1-1). It used to be unlinked here,
   // on the model "Stop = /exit = the session is over". The host does not work that way:
@@ -2144,8 +2152,8 @@ function saveHandoffAndFastSummary(
     }
 
     // Build fast synchronous summary for immediate context availability.
-    // Background llm-summary will produce a richer Haiku version later;
-    // context injection query (ORDER BY created_at_epoch DESC, id DESC) auto-prefers latest.
+    // The background llm-summary spawned above upgrades this same row in place later,
+    // without moving its timestamp.
     try {
       const { request: fastRequestRaw, completed: fastCompletedRaw } = readFastSummarySource(
         db,
@@ -2166,13 +2174,17 @@ function saveHandoffAndFastSummary(
         if (errors.length > 0) fastRemainingRaw = errors.join('; ');
       }
 
+      // One row per session: when Stop already wrote the previous session's row, this updates
+      // it rather than INSERTing a second one beside it (80 live sessions had two, 2026-09-26).
+      // The gate is unchanged, so the row moves to `now` exactly when the second row used to
+      // be written with it.
       if (fastRequestRaw || fastCompletedRaw) {
-        insertFastSummary(db, {
+        writeClearSummary(db, {
           sessionId: prevSessionId,
           project: prevProject || project,
-          now,
           values: { request: fastRequestRaw, completed: fastCompletedRaw, remaining: fastRemainingRaw },
           limits: FAST_SUMMARY_LIMITS.sessionStart,
+          now,
         });
       }
     } catch (e) {
@@ -2244,38 +2256,32 @@ function buildFallbackFastSummary(db, { project, now, prevSessionId }) {
       const recentSession = db
         .prepare(
           `
-        SELECT content_session_id, project FROM sdk_sessions
+        SELECT content_session_id, project FROM sdk_sessions s
         WHERE project = ? AND status = 'completed' AND completed_at_epoch > ?
+          AND NOT EXISTS (SELECT 1 FROM session_summaries WHERE memory_session_id = s.content_session_id)
         ORDER BY completed_at_epoch DESC LIMIT 1
       `,
         )
         .get(project, Date.now() - 120000); // within last 2 minutes
 
+      // "Has no summary" is in the WHERE, not checked after LIMIT 1: every Stop now records
+      // itself (P3-6), so a parallel session still live ranks by its latest turn and, holding a
+      // summary, would take the one slot from the session that actually exited.
       if (recentSession) {
-        const hasSummary = db
-          .prepare(
-            `
-          SELECT 1 FROM session_summaries WHERE memory_session_id = ? LIMIT 1
-        `,
-          )
-          .get(recentSession.content_session_id);
-
-        if (!hasSummary) {
-          const { request: frRaw, completed: fcRaw } = readFastSummarySource(
-            db,
-            recentSession.content_session_id,
-          );
-          if (frRaw || fcRaw) {
-            // No remaining_items on this path: an /exit restart has no handoff and no
-            // episode snapshot to infer one from. It was a bare '' in the SQL before.
-            insertFastSummary(db, {
-              sessionId: recentSession.content_session_id,
-              project,
-              now,
-              values: { request: frRaw, completed: fcRaw },
-              limits: FAST_SUMMARY_LIMITS.exitRestart,
-            });
-          }
+        const { request: frRaw, completed: fcRaw } = readFastSummarySource(
+          db,
+          recentSession.content_session_id,
+        );
+        if (frRaw || fcRaw) {
+          // No remaining_items on this path: an /exit restart has no handoff and no
+          // episode snapshot to infer one from. It was a bare '' in the SQL before.
+          insertFastSummary(db, {
+            sessionId: recentSession.content_session_id,
+            project,
+            now,
+            values: { request: frRaw, completed: fcRaw },
+            limits: FAST_SUMMARY_LIMITS.exitRestart,
+          });
         }
       }
     } catch (e) {

package/install.mjs

@@ -1604,7 +1604,8 @@ async function status() {
       const Database = (await import('better-sqlite3')).default;
       const db = new Database(DB_PATH, { readonly: true });
       const obs = db.prepare('SELECT COUNT(*) as c FROM observations').get();
-      const sess = db.prepare('SELECT COUNT(*) as c FROM session_summaries').get();
+      // DISTINCT, like stats: a session can own several summary rows (legacy duplicates).
+      const sess = db.prepare('SELECT COUNT(DISTINCT memory_session_id) as c FROM session_summaries').get();
       db.close();
       push('ok', 'database', `Database: ${obs.c} observations, ${sess.c} sessions`, {
         exists: true,
@@ -2603,8 +2604,9 @@ async function doctor() {
       const Database = (await import('better-sqlite3')).default;
       const db = new Database(DB_PATH, { readonly: true });
       const obsCount = db.prepare('SELECT COUNT(*) as cnt FROM observations').get()?.cnt || 0;
-      // Align with stats / MCP mem_stats: session_summaries, not sdk_sessions
-      const sessCount = db.prepare('SELECT COUNT(*) as cnt FROM session_summaries').get()?.cnt || 0;
+      // Align with stats / MCP mem_stats: session_summaries, not sdk_sessions, counted DISTINCT
+      const sessCount =
+        db.prepare('SELECT COUNT(DISTINCT memory_session_id) as cnt FROM session_summaries').get()?.cnt || 0;
       db.close();
       const stats = `DB stats: ${sizeMB}MB, ${obsCount} observations, ${sessCount} sessions`;
       // The read succeeds on a too-new file — the tables are still there — so this

package/lib/fast-summary.mjs

@@ -9,10 +9,22 @@
 // v3.35.2, and the comment in one of these blocks announcing "parity with the other"
 // is the tell that parity was being maintained by hand.
 //
-// NOT collapsed in here: hook-llm.mjs's summary insert. That row is produced by the
-// model and carries two more columns (lessons, key_decisions); it is a different
-// record that happens to share a table, and merging it would mean inventing a shape
-// that fits neither.
+// ONE ROW PER SESSION. Stop fires once per assistant TURN (the session file survives it
+// since R10-P1-1), so every writer here runs many times against a session that already has
+// a row. Each one lands on the session's newest row (`newestSummaryId`) and INSERTs only when
+// there is none: Stop (`writeStopSummary`), SessionStart's /clear-or-/compact path
+// (`writeClearSummary`) and hook-llm.mjs's model upgrade (`mergeModelSummary`). The
+// /exit-restart fallback in hook.mjs inserts only for a session with no row at all.
+// Inserting instead left one live session with 37 rows in 65 minutes, which is 9 and 10 of
+// the top ten session search hits for its own vocabulary.
+//
+// Which writer wins a field depends on where that field came from, recorded per field at
+// the head of `notes` (parseSummaryNotes): the assistant's own report beats the model's
+// summary, which beats the last observation titles.
+//
+// The model's write lives here too (`mergeModelSummary`): its precedence against the other
+// two writers is the point of this module, and keeping the three in one place is what lets
+// them agree on it.
 import { scrubRecord } from './scrub-record.mjs';
 import { truncate } from '../format-utils.mjs';
 
@@ -109,3 +121,300 @@ export function insertFastSummary(db, { sessionId, project, values, limits, now
     now.getTime(),
   );
 }
+
+/**
+ * Where a row's Done and Not done came from, stored as the head of `notes`:
+ *
+ *   `done<report|model|titles> left<report|other>[ <Failed / Uncertain lines>]`
+ *
+ *  - done: `report` = the assistant's own Done; `model` = the LLM summary; `titles` = the last
+ *    observation titles, a fallback.
+ *  - left: `report` = the assistant's own Not done, where '' means "nothing left"; `other` =
+ *    the model's inference or the handoff's unfinished list, which only fill a gap.
+ *
+ * Precedence per field: report > model > titles / other. It is recorded per FIELD because one
+ * report can carry a Not done and no Done, or only Failed lines; a single per-row tag read
+ * those as a full report and froze stale titles as its Done (v6.13.5 delta review P2-1,
+ * P2-2). Rows written before this carry older values: `fast` and bare Failed / Uncertain
+ * text read as done = titles, left = other (so fresh titles or a report replace them — a
+ * pre-upgrade report Done among them can be replaced once); `llm`, '' and NULL read as done
+ * = model, left = other; any EMPTY Done takes the titles whatever its tag. `get` prints
+ * `notes` as stored; FTS indexes it at weight 1, and each tag is a single token nobody types.
+ * A space separates the head from the lines because `truncate` folds newlines into spaces.
+ */
+export function parseSummaryNotes(notes) {
+  const text = typeof notes === 'string' ? notes : '';
+  const m = /^done(report|model|titles) left(report|other)(?: ([\s\S]*))?$/.exec(text);
+  if (m) return { done: m[1], left: m[2], lines: m[3] || '' };
+  if (text === '' || text === 'llm') return { done: 'model', left: 'other', lines: '' };
+  if (text === 'fast') return { done: 'titles', left: 'other', lines: '' };
+  return { done: 'titles', left: 'other', lines: text };
+}
+
+/** Inverse of parseSummaryNotes. `lines` must already be scrubbed. */
+export function formatSummaryNotes({ done, left, lines }, max) {
+  const head = `done${done} left${left}`;
+  if (!lines) return head;
+  return truncate(`${head} ${lines}`, max ?? Number.MAX_SAFE_INTEGER);
+}
+
+/**
+ * The session's summary row every later write lands on: its newest, by the same order Last
+ * Session reads (`created_at_epoch DESC, id DESC`). Rows older than it exist only from before
+ * one-row-per-session, or from two writers racing an empty session.
+ *
+ * @returns {number|null}
+ */
+export function newestSummaryId(db, sessionId) {
+  const row = db
+    .prepare(
+      `
+    SELECT id FROM session_summaries
+    WHERE memory_session_id = ?
+    ORDER BY created_at_epoch DESC, id DESC
+    LIMIT 1
+  `,
+    )
+    .get(sessionId);
+  return row ? row.id : null;
+}
+
+const nonEmpty = (v) => (typeof v === 'string' && v !== '' ? v : null);
+
+/** Scrub one raw value, then truncate it: the order insertFastSummary documents. */
+function clean(field, value, max) {
+  return truncate(scrubRecord('session_summaries', { [field]: value || '' })[field], max);
+}
+
+/**
+ * Stop's write, on every turn. `report` is this turn's tail extract ({done, notDone, lines}
+ * — lines are its Failed / Uncertain lines, raw); `source` is readFastSummarySource's output.
+ * The session's first write INSERTs; every later one updates that row:
+ *  - a Done in the report replaces `completed` (done = report); without one, a `titles` row
+ *    takes the current titles;
+ *  - any Done or Not done makes `remaining_items` this report's Not done, '' included
+ *    (left = report) — a Done with no Not done says nothing is left;
+ *  - Failed / Uncertain lines replace the previous report's whenever the tail carries a
+ *    report or such lines.
+ * The timestamp is the first write's. Read and write share one IMMEDIATE transaction, so a
+ * model upgrade committing in between cannot be overwritten with a stale read.
+ */
+export function writeStopSummary(db, { sessionId, project, report, source, now, limits }) {
+  const done = clean('completed', report.done, limits.completed);
+  const notDone = clean('remaining_items', report.notDone, limits.remaining);
+  const lines = scrubRecord('session_summaries', { notes: report.lines || '' }).notes;
+  const titles = clean('completed', source.completed, limits.completed);
+  const hasReport = Boolean(done || notDone);
+  db.transaction(() => {
+    const id = newestSummaryId(db, sessionId);
+    if (id === null) {
+      const completed = done || titles;
+      if (!(source.request || completed || notDone)) return;
+      db.prepare(INSERT_SQL).run(
+        sessionId,
+        project,
+        clean('request', source.request, limits.request),
+        completed,
+        notDone,
+        formatSummaryNotes(
+          { done: done ? 'report' : 'titles', left: hasReport ? 'report' : 'other', lines },
+          limits.notes,
+        ),
+        now.toISOString(),
+        now.getTime(),
+      );
+      return;
+    }
+    const row = db
+      .prepare('SELECT completed, remaining_items, notes FROM session_summaries WHERE id = ?')
+      .get(id);
+    const prov = parseSummaryNotes(row.notes);
+    let completed = row.completed;
+    let remaining = row.remaining_items;
+    if (done) {
+      completed = done;
+      prov.done = 'report';
+    } else if (titles && (prov.done === 'titles' || !nonEmpty(row.completed))) {
+      // A titles Done follows the current titles, and an EMPTY Done takes them whatever its
+      // tag: a model-created row without a Done, or a legacy '' / NULL notes row (third
+      // review P3-1), must not block the fallback.
+      completed = titles;
+      prov.done = 'titles';
+    }
+    if (hasReport) {
+      remaining = notDone;
+      prov.left = 'report';
+    }
+    if (hasReport || lines) prov.lines = lines;
+    db.prepare('UPDATE session_summaries SET completed = ?, remaining_items = ?, notes = ? WHERE id = ?').run(
+      completed,
+      remaining,
+      formatSummaryNotes(prov, limits.notes),
+      id,
+    );
+  }).immediate();
+}
+
+/**
+ * SessionStart's previous-session write (/clear or /compact). It has the opening prompt, the
+ * last observation titles and the handoff's unfinished list:
+ *  - no row yet: INSERT (done = titles, left = other);
+ *  - `request` fills a gap only;
+ *  - `completed`: a `titles` row takes the fresh titles, any other fills a gap only;
+ *  - `remaining_items`: a `report` Not done is left alone ('' = nothing left); otherwise it
+ *    fills a gap only.
+ * The row moves to `now`: this runs when the previous session ended, which is what its own
+ * INSERT used to record, and Last Session orders by it.
+ */
+export function writeClearSummary(db, { sessionId, project, values, limits, now }) {
+  const request = clean('request', values.request, limits.request);
+  const titles = clean('completed', values.completed, limits.completed);
+  const unfinished = clean('remaining_items', values.remaining, limits.remaining);
+  db.transaction(() => {
+    const id = newestSummaryId(db, sessionId);
+    if (id === null) {
+      db.prepare(INSERT_SQL).run(
+        sessionId,
+        project,
+        request,
+        titles,
+        unfinished,
+        formatSummaryNotes({ done: 'titles', left: 'other', lines: '' }),
+        now.toISOString(),
+        now.getTime(),
+      );
+      return;
+    }
+    const row = db
+      .prepare('SELECT request, completed, remaining_items, notes FROM session_summaries WHERE id = ?')
+      .get(id);
+    const prov = parseSummaryNotes(row.notes);
+    const completed =
+      prov.done === 'titles' && titles ? titles : (nonEmpty(row.completed) ?? (titles || row.completed));
+    const remaining =
+      prov.left === 'report'
+        ? row.remaining_items
+        : (nonEmpty(row.remaining_items) ?? (unfinished || row.remaining_items));
+    db.prepare(
+      `UPDATE session_summaries SET request = ?, completed = ?, remaining_items = ?, created_at = ?, created_at_epoch = ?
+       WHERE id = ?`,
+    ).run(
+      nonEmpty(row.request) ?? (request || row.request),
+      completed,
+      remaining,
+      now.toISOString(),
+      now.getTime(),
+      id,
+    );
+  }).immediate();
+}
+
+/**
+ * Whether a Stop later than the one at `spawnEpoch` has been recorded for the session
+ * (sdk_sessions.completed_at_epoch holds the LATEST Stop). Stop spawns one model worker per
+ * turn and two of them can finish out of order; the later Stop's worker reads the newer
+ * window and owns the row, so this one's reply must not land after it (P3-6). Not a strict
+ * superset: observations can be deleted between the two reads (the episode upgrade-delete),
+ * and the later worker can exit on no-obs / slot-timeout / an empty reply, leaving the row an
+ * earlier turn behind — the summary_worker metric pairs the two by session. A missing or
+ * non-numeric epoch is never superseded.
+ */
+export function summarySuperseded(db, sessionId, spawnEpoch) {
+  if (!Number.isFinite(spawnEpoch) || spawnEpoch <= 0) return false;
+  const latest = db
+    .prepare('SELECT completed_at_epoch AS e FROM sdk_sessions WHERE content_session_id = ?')
+    .get(sessionId)?.e;
+  return Number.isFinite(latest) && latest > spawnEpoch;
+}
+
+const MODEL_TEXT_FIELDS = ['request', 'investigated', 'learned', 'next_steps'];
+const MODEL_JSON_FIELDS = ['lessons', 'key_decisions'];
+const SUMMARY_COLUMNS = [...MODEL_TEXT_FIELDS, 'completed', 'remaining_items', ...MODEL_JSON_FIELDS];
+
+/**
+ * The LLM worker's write. `fields` are the model's values, already scrubbed (lessons /
+ * key_decisions as a JSON string or null). Lands on the session's newest row; a field the
+ * model left empty falls back to the row's own value, then to the session's older rows newest
+ * first (legacy duplicates, races), so a degraded reply erases nothing. Per field:
+ *  - `completed`: a `report` Done is kept; otherwise the model's replaces it (done = model);
+ *  - `remaining_items`: a `report` Not done is kept, '' included; otherwise the model's
+ *    replaces it;
+ *  - everything else: the model's replaces it.
+ * The row's timestamp is NOT moved (D#79): this worker can finish after the NEXT session has
+ * written its first row. A session with no row is inserted at its own last prompt, not at the
+ * worker's finish, for the same reason.
+ *
+ * `spawnEpoch` is the epoch of the Stop that spawned this worker; when a later Stop has been
+ * recorded, nothing is written and false is returned (see summarySuperseded). Omitted — the
+ * /clear spawn, a worker spawned by an older version — it always writes.
+ */
+export function mergeModelSummary(db, { sessionId, project, fields, now, spawnEpoch }) {
+  return db
+    .transaction(() => {
+      if (summarySuperseded(db, sessionId, spawnEpoch)) return false;
+      const id = newestSummaryId(db, sessionId);
+      if (id === null) {
+        const last = db
+          .prepare('SELECT MAX(created_at_epoch) AS e FROM user_prompts WHERE content_session_id = ?')
+          .get(sessionId)?.e;
+        const stamp = Number.isFinite(last) && last > 0 && last <= now.getTime() ? new Date(last) : now;
+        db.prepare(
+          `INSERT INTO session_summaries (memory_session_id, project, request, investigated, learned, completed, next_steps,
+           remaining_items, files_read, files_edited, notes, lessons, key_decisions, created_at, created_at_epoch)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', '[]', ?, ?, ?, ?, ?)`,
+        ).run(
+          sessionId,
+          project,
+          fields.request || '',
+          fields.investigated || '',
+          fields.learned || '',
+          fields.completed || '',
+          fields.next_steps || '',
+          fields.remaining_items || '',
+          formatSummaryNotes({
+            done: nonEmpty(fields.completed) ? 'model' : 'titles',
+            left: 'other',
+            lines: '',
+          }),
+          fields.lessons ?? null,
+          fields.key_decisions ?? null,
+          stamp.toISOString(),
+          stamp.getTime(),
+        );
+        return true;
+      }
+      const rows = db
+        .prepare(
+          `SELECT id, notes, ${SUMMARY_COLUMNS.join(', ')} FROM session_summaries
+         WHERE memory_session_id = ? ORDER BY created_at_epoch DESC, id DESC`,
+        )
+        .all(sessionId);
+      const own = rows.find((r) => r.id === id);
+      const siblings = rows.filter((r) => r.id !== id);
+      const floor = (col) =>
+        nonEmpty(own[col]) ?? siblings.map((r) => nonEmpty(r[col])).find(Boolean) ?? own[col];
+      const prov = parseSummaryNotes(own.notes);
+      const next = {};
+      for (const col of [...MODEL_TEXT_FIELDS, ...MODEL_JSON_FIELDS])
+        next[col] = nonEmpty(fields[col]) ?? floor(col);
+      if (prov.done !== 'report' && nonEmpty(fields.completed)) {
+        next.completed = fields.completed;
+        prov.done = 'model';
+      } else {
+        next.completed = floor('completed');
+      }
+      next.remaining_items =
+        prov.left === 'report'
+          ? own.remaining_items
+          : (nonEmpty(fields.remaining_items) ?? floor('remaining_items'));
+      db.prepare(
+        `UPDATE session_summaries SET ${SUMMARY_COLUMNS.map((c) => `${c} = ?`).join(', ')}, notes = ? WHERE id = ?`,
+      ).run(
+        ...SUMMARY_COLUMNS.map((c) => next[c]),
+        formatSummaryNotes(prov, FAST_SUMMARY_LIMITS.stop.notes),
+        id,
+      );
+      return true;
+    })
+    .immediate();
+}

package/lib/stats-core.mjs

@@ -36,12 +36,17 @@ export function computeStatsFeed(
   const projectFilter = project ? 'AND project = ?' : '';
   const baseParams = project ? [project] : [];
 
-  // Total counts (session_summaries, not sdk_sessions — CLI↔MCP aligned)
+  // Total counts (session_summaries, not sdk_sessions — CLI↔MCP aligned). Sessions are counted
+  // DISTINCT: a session can own several summary rows (legacy ones from before one row per
+  // session: 458 rows for 312 sessions on the live DB before a one-off dedup, 2026-09-26), and both faces print this
+  // number as "N sessions".
   const obsTotal = db
     .prepare(`SELECT COUNT(*) as c FROM observations WHERE 1=1 ${projectFilter}`)
     .get(...baseParams);
   const sessTotal = db
-    .prepare(`SELECT COUNT(*) as c FROM session_summaries WHERE 1=1 ${projectFilter}`)
+    .prepare(
+      `SELECT COUNT(DISTINCT memory_session_id) as c FROM session_summaries WHERE 1=1 ${projectFilter}`,
+    )
     .get(...baseParams);
   const promptTotal = project
     ? db
@@ -56,7 +61,9 @@ export function computeStatsFeed(
     .prepare(`SELECT COUNT(*) as c FROM observations WHERE created_at_epoch >= ? ${projectFilter}`)
     .get(cutoff, ...baseParams);
   const sessRecent = db
-    .prepare(`SELECT COUNT(*) as c FROM session_summaries WHERE created_at_epoch >= ? ${projectFilter}`)
+    .prepare(
+      `SELECT COUNT(DISTINCT memory_session_id) as c FROM session_summaries WHERE created_at_epoch >= ? ${projectFilter}`,
+    )
     .get(cutoff, ...baseParams);
 
   // Type distribution (recent)

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.13.4",
+  "version": "6.13.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.13.4",
+      "version": "6.13.6",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.13.4",
+  "version": "6.13.6",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. Hybrid FTS5 + TF-IDF search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",