claude-mem-lite 2.30.0 → 2.30.1

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.30.0",
+      "version": "2.30.1",
       "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.30.0",
+  "version": "2.30.1",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/hook-context.mjs

@@ -241,9 +241,12 @@ export function cleanupClaudeMdLegacyBlock() {
  * @param {import('better-sqlite3').Database} db Opened main DB
  * @param {string} project Canonical project name (from inferProject())
  * @param {Date} [now=new Date()] Clock reference for time windows and table header
+ * @param {string|null} [currentCcSessionId=null] Claude Code session id — when provided,
+ *   the "Working State (from /clear)" block is filtered to handoffs owned by this
+ *   session, preventing parallel-session bleed (see docs/bug.txt).
  * @returns {string} Joined markdown lines (without <claude-mem-context> wrappers)
  */
-export function buildSessionContextLines(db, project, now = new Date()) {
+export function buildSessionContextLines(db, project, now = new Date(), currentCcSessionId = null) {
   // 1. Token-budgeted observation selection
   const selected = selectWithTokenBudget(db, project, 2000);
   const observations = selected.observations;
@@ -334,13 +337,22 @@ export function buildSessionContextLines(db, project, now = new Date()) {
     }
   }
 
-  // 5. Working state from latest /clear handoff
-  const prevClearHandoff = db.prepare(`
-    SELECT working_on, unfinished, key_files
-    FROM session_handoffs
-    WHERE project = ? AND type = 'clear'
-    ORDER BY created_at_epoch DESC LIMIT 1
-  `).get(project);
+  // 5. Working state from latest /clear handoff.
+  // Session scoping: when currentCcSessionId is provided, restrict to this session's
+  // own clear handoff so parallel sessions don't see each other's Working State block.
+  const prevClearHandoff = currentCcSessionId
+    ? db.prepare(`
+        SELECT working_on, unfinished, key_files
+        FROM session_handoffs
+        WHERE project = ? AND type = 'clear' AND session_id = ?
+        ORDER BY created_at_epoch DESC LIMIT 1
+      `).get(project, currentCcSessionId)
+    : db.prepare(`
+        SELECT working_on, unfinished, key_files
+        FROM session_handoffs
+        WHERE project = ? AND type = 'clear'
+        ORDER BY created_at_epoch DESC LIMIT 1
+      `).get(project);
 
   const handoffLines = [];
   if (prevClearHandoff) {

package/hook-handoff.mjs

@@ -89,12 +89,12 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
   const allText = [workingOn, ...completed.map(c => c.title).filter(Boolean), unfinished].join(' ');
   const keywords = extractMatchKeywords(allText, [...fileSet]);
 
-  // UPSERT
+  // UPSERT keyed on (project, type, session_id) — parallel sessions coexist.
+  // Same session re-writing its own handoff (e.g. repeated /clear) updates in place.
   db.prepare(`
     INSERT INTO session_handoffs (project, type, session_id, working_on, completed, unfinished, key_files, key_decisions, match_keywords, created_at_epoch)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(project, type) DO UPDATE SET
-      session_id = excluded.session_id,
+    ON CONFLICT(project, type, session_id) DO UPDATE SET
       working_on = excluded.working_on,
       completed = excluded.completed,
       unfinished = excluded.unfinished,
@@ -116,18 +116,41 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
 
 /**
  * Detect if user's prompt indicates continuation of previous work.
+ * Stage 0: Non-expired clear handoff + short prompt → auto-continue.
  * Stage 1: Explicit keyword match (zero false positives).
  * Stage 2: FTS5-style term overlap with handoff keywords.
+ *
+ * Session scoping (currentCcSessionId): when provided, clear handoffs from a
+ * DIFFERENT session are excluded from Stage 0 auto-match and from the general
+ * pool (prevents cross-session bleed when running parallel sessions for the
+ * same project — see docs/bug.txt). When null, legacy behavior is preserved.
+ *
  * @param {Database} db Opened main database
  * @param {string} promptText User's prompt text
  * @param {string} project Project identifier
+ * @param {string|null} [currentCcSessionId=null] Claude Code session id for scoping
  * @returns {boolean}
  */
-export function detectContinuationIntent(db, promptText, project) {
-  // Stage 0: Non-expired 'clear' handoff — assume continuation unless long unrelated prompt
-  const clearHandoff = db.prepare(`
-    SELECT created_at_epoch, match_keywords FROM session_handoffs WHERE project = ? AND type = 'clear'
-  `).get(project);
+export function detectContinuationIntent(db, promptText, project, currentCcSessionId = null) {
+  // Input guard: empty / whitespace / single-char prompts never trigger auto-injection.
+  // The bug was a single-char 'a' + fresh clear handoff → Stage 0 auto-match.
+  if (!promptText || typeof promptText !== 'string') return false;
+  if (promptText.trim().length < 2) return false;
+
+  // Stage 0: Non-expired 'clear' handoff — assume continuation unless long unrelated prompt.
+  // Session scoping: with currentCcSessionId, only your OWN clear handoff qualifies.
+  const clearHandoff = currentCcSessionId
+    ? db.prepare(`
+        SELECT created_at_epoch, match_keywords FROM session_handoffs
+        WHERE project = ? AND type = 'clear' AND session_id = ?
+        ORDER BY created_at_epoch DESC LIMIT 1
+      `).get(project, currentCcSessionId)
+    : db.prepare(`
+        SELECT created_at_epoch, match_keywords FROM session_handoffs
+        WHERE project = ? AND type = 'clear'
+        ORDER BY created_at_epoch DESC LIMIT 1
+      `).get(project);
+
   if (clearHandoff && (Date.now() - clearHandoff.created_at_epoch <= HANDOFF_EXPIRY_CLEAR)) {
     // Short/ambiguous prompts: assume continuation (user may say "ok", "start", etc.)
     if (promptText.length < 40) return true;
@@ -142,11 +165,20 @@ export function detectContinuationIntent(db, promptText, project) {
   // Stage 1: Explicit keyword match — always works, even without handoff
   if (CONTINUE_KEYWORDS.test(promptText)) return true;
 
-  // Stage 2: FTS5-style term overlap with handoff keywords
-  const handoffs = db.prepare(`
-    SELECT type, match_keywords, created_at_epoch FROM session_handoffs
-    WHERE project = ? ORDER BY created_at_epoch DESC
-  `).all(project);
+  // Stage 2: FTS5-style term overlap with handoff keywords.
+  // Session scoping: exit handoffs from OTHER sessions are still candidates (you may
+  // be resuming a previous session), but clear handoffs must be same-session.
+  const handoffs = currentCcSessionId
+    ? db.prepare(`
+        SELECT type, match_keywords, created_at_epoch FROM session_handoffs
+        WHERE project = ?
+          AND ((type = 'clear' AND session_id = ?) OR type = 'exit')
+        ORDER BY created_at_epoch DESC
+      `).all(project, currentCcSessionId)
+    : db.prepare(`
+        SELECT type, match_keywords, created_at_epoch FROM session_handoffs
+        WHERE project = ? ORDER BY created_at_epoch DESC
+      `).all(project);
   if (handoffs.length === 0) return false;
 
   // Filter expired handoffs
@@ -176,18 +208,32 @@ export function detectContinuationIntent(db, promptText, project) {
 /**
  * Render handoff injection text for stdout.
  * Reads the most recent handoff + optional session summary.
+ *
+ * Session scoping (currentCcSessionId): when provided,
+ *   - clear handoffs: only from the CURRENT session (you continue your own /clear)
+ *   - exit handoffs:  only from OTHER sessions (you resume a previous exit)
+ * When null, legacy behavior (most-recent handoff regardless of session).
+ *
  * @param {Database} db Opened main database
  * @param {string} project Project identifier
+ * @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) {
+export function renderHandoffInjection(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 (1h) must not shadow a still-valid 'exit' handoff (7d).
-  const handoffs = db.prepare(`
-    SELECT * FROM session_handoffs
-    WHERE project = ? ORDER BY created_at_epoch DESC LIMIT 5
-  `).all(project);
+  // A newer but expired 'clear' handoff must not shadow a still-valid 'exit' handoff.
+  const handoffs = currentCcSessionId
+    ? db.prepare(`
+        SELECT * FROM session_handoffs
+        WHERE project = ?
+          AND ((type = 'clear' AND session_id = ?) OR (type = 'exit' AND session_id != ?))
+        ORDER BY created_at_epoch DESC LIMIT 5
+      `).all(project, currentCcSessionId, currentCcSessionId)
+    : db.prepare(`
+        SELECT * FROM session_handoffs
+        WHERE project = ? ORDER BY created_at_epoch DESC LIMIT 5
+      `).all(project);
   const handoff = handoffs.find(h => {
     const age = now - h.created_at_epoch;
     const maxAge = h.type === 'clear' ? HANDOFF_EXPIRY_CLEAR : HANDOFF_EXPIRY_EXIT;

package/hook.mjs

@@ -288,8 +288,21 @@ function triggerErrorRecall(db, toolInput, response) {
 // ─── Stop Handler ───────────────────────────────────────────────────────────
 
 async function handleStop() {
-  // Capture session info BEFORE cleanup
-  const sessionId = getSessionId();
+  // Read Claude Code's real session_id from hook stdin for parallel-session scoping.
+  // This is the stable CC identifier — the mem plugin's file-based getSessionId()
+  // collides across parallel sessions for the same project (see docs/bug.txt).
+  let ccSessionId = null;
+  try {
+    const raw = await readStdin();
+    const hookData = JSON.parse(raw.text);
+    if (typeof hookData?.session_id === 'string' && hookData.session_id.length > 0) {
+      ccSessionId = hookData.session_id;
+    }
+  } catch { /* stdin unavailable — fall back to local session id */ }
+
+  // Capture session info BEFORE cleanup. Prefer CC session id (parallel-safe);
+  // fall back to file-based id for backward compat.
+  const sessionId = ccSessionId || getSessionId();
   const project = inferProject();
 
   // Snapshot episode BEFORE flush for handoff extraction
@@ -384,6 +397,17 @@ async function handleStop() {
 // ─── SessionStart Handler + CLAUDE.md Persistence (Tier 1 A, E) ─────────────
 
 async function handleSessionStart() {
+  // Read CC real session_id from hook stdin — used to scope handoff rows so parallel
+  // sessions for the same project don't clobber each other (see docs/bug.txt).
+  let ccSessionId = null;
+  try {
+    const raw = await readStdin();
+    const hookData = JSON.parse(raw.text);
+    if (typeof hookData?.session_id === 'string' && hookData.session_id.length > 0) {
+      ccSessionId = hookData.session_id;
+    }
+  } catch { /* stdin unavailable — legacy behavior */ }
+
   // Snapshot episode BEFORE flush for handoff extraction
   const episodeSnapshot = readEpisodeRaw();
 
@@ -566,15 +590,21 @@ async function handleSessionStart() {
     let prevClearHandoff = null;
 
     if (prevSessionId) {
-      // Save handoff for cross-session continuity (/clear or /compact)
-      try { buildAndSaveHandoff(db, prevSessionId, prevProject || project, 'clear', episodeSnapshot); }
+      // Save handoff for cross-session continuity (/clear or /compact).
+      // Prefer CC session id (stable across /clear within same CC session, and
+      // unique across parallel sessions for the same project) so UserPromptSubmit
+      // can scope by hookData.session_id. Fall back to the mem plugin's file-based
+      // id for legacy/test paths.
+      const handoffSessionId = ccSessionId || prevSessionId;
+      try { buildAndSaveHandoff(db, handoffSessionId, prevProject || project, 'clear', episodeSnapshot); }
       catch (e) { debugCatch(e, 'session-start-handoff'); }
 
-      // Read the just-saved handoff for downstream consumers (fast summary remaining, working state)
+      // Read the just-saved handoff for downstream consumers (fast summary remaining, working state).
+      // Session-scoped read to avoid picking up a parallel session's clear handoff.
       try {
         prevClearHandoff = db.prepare(
-          'SELECT working_on, unfinished, key_files FROM session_handoffs WHERE project = ? AND type = ?'
-        ).get(prevProject || project, 'clear');
+          'SELECT working_on, unfinished, key_files FROM session_handoffs WHERE project = ? AND type = ? AND session_id = ?'
+        ).get(prevProject || project, 'clear', handoffSessionId);
       } catch {}
 
       // Generate session summary for previous session (background Haiku — richer version)
@@ -689,7 +719,9 @@ async function handleSessionStart() {
     // Build the full context body via shared helper (also used by `mem-cli context`).
     // Queries session_summaries, key observations, clear handoff, and the
     // token-budgeted observation pool directly from the DB.
-    const fullContext = buildSessionContextLines(db, project, now);
+    // Pass CC session id so the Working State block is scoped to this session,
+    // preventing parallel sessions from seeing each other's /clear handoff.
+    const fullContext = buildSessionContextLines(db, project, now, ccSessionId);
 
     // Stdout is the sole context-delivery channel. The SessionStart hook output
     // is injected as a <system-reminder> at session start, giving Claude the
@@ -766,16 +798,29 @@ async function handleUserPrompt() {
       now.toISOString(), now.getTime()
     );
 
-    // Cross-session handoff injection (first 3 prompts window, before semantic memory)
+    // Cross-session handoff injection (first 3 prompts window, before semantic memory).
+    // Use Claude Code's real session_id from hook stdin to scope handoffs to this CC
+    // session — prevents cross-session bleed when running parallel sessions for the
+    // same project (see docs/bug.txt). Falls back to null (legacy behavior) if the
+    // hook input does not carry session_id.
+    const ccSessionId = typeof hookData.session_id === 'string' && hookData.session_id.length > 0
+      ? hookData.session_id
+      : null;
     if (counter?.prompt_counter <= 3) {
       try {
-        if (detectContinuationIntent(db, promptText, project)) {
-          const injection = renderHandoffInjection(db, project);
+        if (detectContinuationIntent(db, promptText, project, ccSessionId)) {
+          const injection = renderHandoffInjection(db, project, ccSessionId);
           if (injection) {
             process.stdout.write(injection + '\n');
             // Consume clear handoff after injection to prevent duplicate injection on prompts 2-3.
-            // Exit handoffs are kept (7d TTL, content-dependent keyword/FTS matching won't re-trigger).
-            try { db.prepare("DELETE FROM session_handoffs WHERE project = ? AND type = 'clear'").run(project); } catch {}
+            // Scope the delete to THIS session's clear handoff — do not clobber parallel sessions' rows.
+            try {
+              if (ccSessionId) {
+                db.prepare("DELETE FROM session_handoffs WHERE project = ? AND type = 'clear' AND session_id = ?").run(project, ccSessionId);
+              } else {
+                db.prepare("DELETE FROM session_handoffs WHERE project = ? AND type = 'clear'").run(project);
+              }
+            } catch {}
           }
         }
       } catch (e) { debugCatch(e, 'handleUserPrompt-handoff'); }

package/package.json

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

package/schema.mjs

@@ -13,7 +13,7 @@ export const DB_PATH = join(DB_DIR, 'claude-mem-lite.db');
 export const REGISTRY_DB_PATH = join(DB_DIR, 'resource-registry.db');
 
 // Increment when schema changes (tables, columns, indexes, FTS, migrations)
-export const CURRENT_SCHEMA_VERSION = 21;
+export const CURRENT_SCHEMA_VERSION = 22;
 
 const CORE_SCHEMA = `
   CREATE TABLE IF NOT EXISTS sdk_sessions (
@@ -91,7 +91,7 @@ const CORE_SCHEMA = `
     key_decisions TEXT,
     match_keywords TEXT,
     created_at_epoch INTEGER,
-    PRIMARY KEY (project, type)
+    PRIMARY KEY (project, type, session_id)
   );
 `;
 
@@ -136,6 +136,42 @@ export function initSchema(db) {
     }
   }
 
+  // session_handoffs PK widen: (project, type) → (project, type, session_id)
+  // Old PK assumed one session per project, causing cross-session handoff overwrite
+  // (see docs/bug.txt). Rebuild table if still on old PK. Idempotent.
+  try {
+    const handoffDdl = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='session_handoffs'`).get();
+    const oldPk = handoffDdl && /PRIMARY KEY\s*\(\s*project\s*,\s*type\s*\)/i.test(handoffDdl.sql);
+    if (oldPk) {
+      const rebuild = db.transaction(() => {
+        db.exec(`
+          CREATE TABLE session_handoffs_new (
+            project TEXT NOT NULL,
+            type TEXT NOT NULL,
+            session_id TEXT NOT NULL,
+            working_on TEXT,
+            completed TEXT,
+            unfinished TEXT,
+            key_files TEXT,
+            key_decisions TEXT,
+            match_keywords TEXT,
+            created_at_epoch INTEGER,
+            PRIMARY KEY (project, type, session_id)
+          )
+        `);
+        db.exec(`
+          INSERT INTO session_handoffs_new
+            (project, type, session_id, working_on, completed, unfinished, key_files, key_decisions, match_keywords, created_at_epoch)
+          SELECT project, type, session_id, working_on, completed, unfinished, key_files, key_decisions, match_keywords, created_at_epoch
+          FROM session_handoffs
+        `);
+        db.exec(`DROP TABLE session_handoffs`);
+        db.exec(`ALTER TABLE session_handoffs_new RENAME TO session_handoffs`);
+      });
+      rebuild();
+    }
+  } catch { /* non-critical — next open retries */ }
+
   // Dedup migration: ensure memory_session_id is unique, then enable FK
   const hasIdx = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='index' AND name='idx_sess_memory_sid'`).get();
   if (!hasIdx) {
@@ -173,6 +209,7 @@ export function initSchema(db) {
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_branch ON observations(branch) WHERE branch IS NOT NULL`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_sessions_project ON sdk_sessions(project)`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_obs_not_compressed ON observations(created_at_epoch DESC) WHERE COALESCE(compressed_into, 0) = 0`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_handoffs_project_time ON session_handoffs(project, type, created_at_epoch DESC)`);
 
   // FTS5 migration: recreate observations_fts when columns are missing (one-time)
   // Detect old FTS5 table missing lesson_learned or search_aliases and recreate with full column set