claude-mem-lite 6.13.5 → 6.13.6

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.13.5",
+      "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.5",
+  "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,7 +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 } from './lib/fast-summary.mjs';
+import { mergeModelSummary, summarySuperseded } from './lib/fast-summary.mjs';
+import { recordMetric } from './lib/metrics.mjs';
+import { DB_DIR } from './schema.mjs';
 import {
   insertObservationRow,
   insertObservationFiles,
@@ -1374,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();
@@ -1397,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(
@@ -1433,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();
@@ -1502,8 +1530,18 @@ ${obsList}`;
         lessons: lessonsJson,
         key_decisions: decisionsJson,
       });
-      mergeModelSummary(db, { sessionId, project, fields: safe, now });
+      if (mergeModelSummary(db, { sessionId, project, fields: safe, now, spawnEpoch })) {
+        outcome('written');
+      } else {
+        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

@@ -1075,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
@@ -1577,11 +1584,13 @@ 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 });
+      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.
@@ -1600,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:
@@ -2246,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/lib/fast-summary.mjs

@@ -309,6 +309,24 @@ export function writeClearSummary(db, { sessionId, project, values, limits, now
   }).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];
@@ -325,70 +343,78 @@ const SUMMARY_COLUMNS = [...MODEL_TEXT_FIELDS, 'completed', 'remaining_items', .
  * 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 }) {
-  db.transaction(() => {
-    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,
+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(
-        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(),
+        ...SUMMARY_COLUMNS.map((c) => next[c]),
+        formatSummaryNotes(prov, FAST_SUMMARY_LIMITS.stop.notes),
+        id,
       );
-      return;
-    }
-    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,
-    );
-  }).immediate();
+      return true;
+    })
+    .immediate();
 }

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.13.5",
+  "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",