claude-mem-lite 3.37.0 → 3.38.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "3.37.0",
+      "version": "3.38.1",
       "source": "./",
       "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": "3.37.0",
+  "version": "3.38.1",
   "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/lib/citation-tracker.mjs

@@ -571,18 +571,24 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
     // superseded_at IS NULL: mirror computeCitationAdoption + the 4 injection SELECTs so a
     // row superseded mid-session (injected live, then auto-dedup supersedes it before this
     // decay resolves) is not decayed/streaked/mutated — defense-in-depth parity.
-    'SELECT id, importance, uncited_streak, last_decided_session_id FROM observations WHERE id = ? AND project = ? AND superseded_at IS NULL'
+    'SELECT id, importance, uncited_streak, last_decided_session_id, last_cited_session_id FROM observations WHERE id = ? AND project = ? AND superseded_at IS NULL'
   );
   // decay_seen_count (v34) bumps on every resolution branch — gives
   // citation-stats a denominator that's same-source as cited_count, so the
   // ratio actually means "cite-rate" instead of mixing decay + UserPromptSubmit.
+  // Promote also stamps last_cited_session_id (v41 promote-idempotency key) so a
+  // same-session re-fire is a no-op. decay_seen_count is bumped by a PARAM, not a
+  // literal +1: a FIRST resolution counts the obs into the denominator (1); a
+  // cross-turn LATE upgrade of an already-resolved obs must NOT re-count it (0), else
+  // cite-rate reads N/2 for a single injected-then-cited obs instead of N/1.
   const updatePromote = db.prepare(`
     UPDATE observations
        SET importance = MIN(?, importance + 1),
            cited_count = cited_count + 1,
            uncited_streak = 0,
            last_decided_session_id = ?,
-           decay_seen_count = decay_seen_count + 1
+           last_cited_session_id = ?,
+           decay_seen_count = decay_seen_count + ?
      WHERE id = ?
   `);
   const updateStreakOnly = db.prepare(`
@@ -619,12 +625,28 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
     for (const id of injected) {
       const row = selectStmt.get(id, project);
       if (!row) continue; // cross-project or deleted
-      if (row.last_decided_session_id === sessionId) continue; // idempotent skip
-      touched++;
+      const decidedThisSession = row.last_decided_session_id === sessionId;
+
       if (cited.has(id)) {
-        updatePromote.run(IMPORTANCE_CAP, sessionId, id);
+        // Promote path — idempotent on last_cited_session_id, NOT last_decided. This is
+        // what lets a citation in a LATER turn upgrade an obs this session already
+        // resolved as uncited: the contract is "cite NEXT time you produce user-visible
+        // text," which may be several turns after injection. A promote resets
+        // uncited_streak and lifts importance, so a same-session demotion that fired at
+        // an earlier turn is naturally undone. Re-firing after the promote is a no-op.
+        if (row.last_cited_session_id === sessionId) continue; // already promoted this session
+        // touched/decay_seen only on the FIRST resolution — a late upgrade re-decides an
+        // obs already in the injected denominator, so re-counting it would inflate both
+        // decay_seen_count and the funnel's injected_n (cite-rate would read N/2, not N/1).
+        const firstResolution = !decidedThisSession;
+        updatePromote.run(IMPORTANCE_CAP, sessionId, sessionId, firstResolution ? 1 : 0, id);
         promoted++;
+        if (firstResolution) touched++;
       } else {
+        // Uncited path — idempotent on last_decided_session_id (unchanged): don't
+        // re-streak an obs already resolved this session.
+        if (decidedThisSession) continue;
+        touched++;
         const nextStreak = (row.uncited_streak || 0) + 1;
         // Demote only when the streak is up AND the project has demonstrably
         // adopted citations. A non-adopting project advances the streak (idempotent
@@ -649,9 +671,11 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
  * R1 — persist one accumulating per-session row of the invocation→cite funnel.
  * Fed by applyCitationDecay's return: `injectedDelta` = obs RESOLVED this Stop
  * (touched), `citedDelta` = obs CITED this Stop (promoted). Idempotent against
- * Stop multi-fire by construction — a re-fired Stop re-resolves nothing (touched
- * is 0 for already-decided obs), so the no-op gate below skips it. A later turn
- * that resolves NEW injections accumulates onto the same (project, session) row.
+ * Stop multi-fire by construction — a pure re-fire re-resolves nothing (touched=0
+ * AND promoted=0), so the (0,0) gate below skips it. A later turn that resolves NEW
+ * injections (touched>0) OR lands a cross-turn LATE citation (touched=0, promoted>0)
+ * accumulates onto the same (project, session) row — the numerator must accrue even
+ * when the denominator doesn't, so the gate skips only when BOTH deltas are 0.
  *
  * Unlike the per-obs cited_count/decay_seen_count counters (lifetime-cumulative,
  * session breakdown lost), this preserves the per-session series that
@@ -667,8 +691,13 @@ export function applyCitationDecay(db, project, injectedIds, citedIds, sessionId
 export function recordCitationFunnel(db, project, sessionId, injectedDelta, citedDelta) {
   if (!db || !project || !sessionId) return;
   const inj = Number(injectedDelta) || 0;
-  if (inj <= 0) return; // nothing resolved this run → no row noise
   const cited = Math.max(0, Number(citedDelta) || 0);
+  // Skip only when BOTH deltas are 0: a pure cross-turn late upgrade contributes
+  // injectedDelta=0 (the obs was already counted at its first resolution) but
+  // citedDelta>0, and that numerator must still fold onto the existing session row
+  // (a late upgrade always has a prior first-resolution row). Pre-v41 the `inj<=0`
+  // gate silently dropped it, under-counting cites in the funnel.
+  if (inj <= 0 && cited <= 0) return; // nothing resolved this run → no row noise
   try {
     db.prepare(`
       INSERT INTO citation_log (project, memory_session_id, resolved_at, injected_n, cited_n)

package/mem-cli.mjs

@@ -2443,16 +2443,34 @@ function cmdCitationStats(db, args) {
   // as the per-project cite rate above; funnel.prior/delta_pt show the direction.
   const funnel = computeCitationFunnelTrend(db, { days });
 
+  // Survivorship-honesty: the per-project rate (cited_count/decay_seen_count over
+  // SURVIVING in-window obs) is doubly biased — GC drops uncited obs from the
+  // denominator and the window excludes older obs — so it overstates adoption (a
+  // project can read 91% while its true lifetime inject→cite is ~6%). citation_log
+  // rows persist across GC, so their per-project sum is the honest historical rate.
+  // Attach both to each row so the text + JSON surface the biased and honest numbers.
+  const funnelByProject = new Map(
+    db.prepare(`SELECT project, COALESCE(SUM(injected_n), 0) inj, COALESCE(SUM(cited_n), 0) cit
+                  FROM citation_log GROUP BY project`).all().map(r => [r.project, r])
+  );
+  for (const r of perProject) {
+    const f = funnelByProject.get(r.project);
+    r.funnel_injected = f ? f.inj : 0;
+    r.funnel_cited = f ? f.cit : 0;
+  }
+
   if (json) {
     out(JSON.stringify({ window_days: days, per_project: perProject, decay_queue: decayQueue, promoted, demoted, data_pollution_note: dataPollutionNote, funnel }, null, 2));
     return;
   }
 
   if (dataPollutionNote) out(`Note: ${dataPollutionNote}\n`);
-  out(`Cite rate by project (last ${days}d, cited / decay-resolutions):`);
+  out(`Cite rate by project (last ${days}d):`);
+  out(`  funnel = lifetime injected→cited (citation_log, GC-durable = honest) · surviving = cited/decay over in-window non-GC'd obs (survivorship-biased, reads high):`);
   for (const r of perProject) {
-    const rate = r.resolved > 0 ? (r.cited * 100 / r.resolved).toFixed(1) + '%' : '—';
-    out(`  ${r.project.padEnd(34)} ${String(rate).padStart(6)}   cited:${r.cited}/${r.resolved}   at_risk:${r.at_risk}`);
+    const funnelRate = r.funnel_injected > 0 ? (r.funnel_cited * 100 / r.funnel_injected).toFixed(1) + '%' : '—';
+    const survRate = r.resolved > 0 ? (r.cited * 100 / r.resolved).toFixed(1) + '%' : '—';
+    out(`  ${r.project.padEnd(30)} funnel ${String(funnelRate).padStart(6)} (${r.funnel_cited}/${r.funnel_injected}) · surviving ${String(survRate).padStart(6)} (${r.cited}/${r.resolved}) · at_risk:${r.at_risk}`);
   }
   out('');
 

package/package.json

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

package/schema.mjs

@@ -98,13 +98,19 @@ export const CODE_DIR = join(homedir(), '.claude-mem-lite');
 // (Haiku summary enrichment lost every session). Pure index reheal (no data migration, no
 // column drop); idempotent. New behavior via the forced pass; LATEST_MIGRATION_COLUMN
 // unchanged (no new column) — same pattern as v35/v36/v38/v39.
-export const CURRENT_SCHEMA_VERSION = 40;
+// v41 (cross-turn late-citation): adds observations.last_cited_session_id (additive,
+// nullable) — the promote idempotency key, split from last_decided_session_id so a
+// citation landing in a LATER turn of the same session can still upgrade a
+// previously-uncited obs (see applyCitationDecay). REAL new column, so unlike v38-v40
+// this DOES advance LATEST_MIGRATION_COLUMN (→ observations.last_cited_session_id);
+// existing DBs reach the ALTER because version 40 != 41 falls through the fast-path.
+export const CURRENT_SCHEMA_VERSION = 41;
 
 // Sentinel column for the LATEST migration set. The fast-path uses this to
 // self-heal half-migrated DBs — schema_version bumped but column ALTERs rolled
 // back (observed once in dev during v2.74.0). Update both the column AND
 // (if needed) the table when adding a new migration batch.
-const LATEST_MIGRATION_COLUMN = { table: 'user_prompts', column: 'cc_session_id' };
+const LATEST_MIGRATION_COLUMN = { table: 'observations', column: 'last_cited_session_id' };
 
 function hasLatestMigrationColumn(db) {
   try {
@@ -264,6 +270,14 @@ const MIGRATIONS = [
   // legacy rows + non-CC/no-stdin invocations read back NULL and the handoff falls
   // back to its legacy unfiltered query.
   'ALTER TABLE user_prompts ADD COLUMN cc_session_id TEXT DEFAULT NULL',
+  // v41 (cross-turn late-citation): promote-idempotency key, split from
+  // last_decided_session_id. applyCitationDecay guards the cited/promote branch on
+  // THIS column so a citation in a LATER turn of the same session can still upgrade a
+  // previously-uncited obs; the uncited/streak branch stays guarded on
+  // last_decided_session_id (so it never double-streaks within a session). Nullable:
+  // legacy rows read NULL and behave exactly as before until their first same-session
+  // late cite.
+  'ALTER TABLE observations ADD COLUMN last_cited_session_id TEXT DEFAULT NULL',
 ];
 
 /**