claude-mem-lite 2.30.0 → 2.31.0

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'browse', 'delete', 'update', 'export', 'compress', 'maintain', 'optimize', 'fts-check', 'registry', 'import', 'enrich', 'help']);
+const CLI_COMMANDS = new Set(['search', 'recent', 'recall', 'get', 'timeline', 'save', 'stats', 'context', 'browse', 'delete', 'update', 'export', 'compress', 'maintain', 'optimize', 'fts-check', 'registry', 'import', 'enrich', 'activity', 'help']);
 const INSTALL_COMMANDS = new Set(['install', 'uninstall', 'status', 'doctor', 'cleanup', 'cleanup-hooks', 'self-update', 'release']);
 
 const cmd = process.argv[2];
@@ -13,6 +13,11 @@ if (cmd === '--version' || cmd === '-v') {
 } else if (cmd === '--help' || cmd === '-h') {
   const { run } = await import('./mem-cli.mjs');
   await run(['help']);
+} else if (cmd === 'doctor' && process.argv.slice(3).includes('--benchmark')) {
+  // doctor --benchmark is a baseline-capture tool, routed through mem-cli (DB layer);
+  // plain `doctor` continues to run the install health-check below.
+  const { run } = await import('./mem-cli.mjs');
+  await run(process.argv.slice(2));
 } else if (CLI_COMMANDS.has(cmd)) {
   const { run } = await import('./mem-cli.mjs');
   await run(process.argv.slice(2));

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

@@ -6,6 +6,11 @@ import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SI
 import {
   HANDOFF_EXPIRY_CLEAR, HANDOFF_EXPIRY_EXIT, HANDOFF_MATCH_THRESHOLD, CONTINUE_KEYWORDS,
 } from './hook-shared.mjs';
+// T10d: import the whole module (not a named export) so tests can spy on
+// gitStateModule.readGitState via vi.spyOn. Named-import bindings are
+// immutable in ESM and cannot be mocked after the fact.
+import * as gitStateModule from './lib/git-state.mjs';
+import * as taskReaderModule from './lib/task-reader.mjs';
 
 /**
  * Build and save a handoff snapshot to session_handoffs table.
@@ -51,6 +56,24 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
       .filter(d => { if (seenDescs.has(d)) return false; seenDescs.add(d); return true; });
     if (pendingDescs.length > 0) unfinished = pendingDescs.join('; ');
   }
+
+  // T10d: TaskList-sourced Unfinished. When no episode pending entries exist,
+  // prefer the structured signal from ~/.claude/tasks/<list>/*.json over the
+  // narrative-only fallback — a user-maintained task list is a stronger signal
+  // than a session with no recent tool activity. When the episode already has
+  // pending entries, those stay (they're fresher than the task file).
+  if (!unfinished) {
+    try {
+      const tasks = taskReaderModule.readProjectTasks({ projectPath: process.cwd() });
+      if (tasks.length > 0) {
+        unfinished = tasks
+          .slice(0, 5)
+          .map(t => `[${t.status}] ${t.title}`)
+          .join('\n');
+      }
+    } catch { /* task reader is best-effort; never block handoff */ }
+  }
+
   // Enrich unfinished with full session edit history from observation narratives.
   // Since handoff is UPSERT (max 2 rows per project), storing more data is free.
   // Always use \n---\n separator so extractUnfinishedSummary can distinguish
@@ -89,19 +112,27 @@ 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
+  // T10d: capture HEAD sha so detectContinuationIntent can anchor on it later.
+  // Best-effort — failures (non-git dir, missing binary, timeout) yield null.
+  let gitShaAtHandoff = null;
+  try {
+    gitShaAtHandoff = gitStateModule.readGitState({ cwd: process.cwd() }).headSha || null;
+  } catch { /* swallow — handoff must still persist */ }
+
+  // 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,
+    INSERT INTO session_handoffs (project, type, session_id, working_on, completed, unfinished, key_files, key_decisions, match_keywords, created_at_epoch, git_sha_at_handoff)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(project, type, session_id) DO UPDATE SET
       working_on = excluded.working_on,
       completed = excluded.completed,
       unfinished = excluded.unfinished,
       key_files = excluded.key_files,
       key_decisions = excluded.key_decisions,
       match_keywords = excluded.match_keywords,
-      created_at_epoch = excluded.created_at_epoch
+      created_at_epoch = excluded.created_at_epoch,
+      git_sha_at_handoff = excluded.git_sha_at_handoff
   `).run(
     project, type, sessionId,
     truncate(workingOn, 1000),
@@ -110,24 +141,68 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
     JSON.stringify([...fileSet].slice(0, 20)),
     decisions.map(d => d.title).join('\n'),
     keywords,
-    Date.now()
+    Date.now(),
+    gitShaAtHandoff,
   );
 }
 
 /**
  * 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;
+
+  // T10d Stage -1: Git-commit anchor — if ANY handoff (any age) has a
+  // git_sha_at_handoff matching current HEAD, the working tree hasn't moved
+  // since that handoff, so assume continuation regardless of time / prompt.
+  //
+  // Trade-off: after weeks of no commits this fires aggressively. Users can
+  // reset by making a commit or by typing a long unrelated prompt (this
+  // anchor runs BEFORE the Stage 0 long-prompt guard, so that escape hatch
+  // does not apply here). This is an MVP choice — see plan 10d concern.
+  try {
+    const currentSha = gitStateModule.readGitState({ cwd: process.cwd() }).headSha;
+    if (currentSha) {
+      const anchor = db.prepare(`
+        SELECT 1 FROM session_handoffs
+        WHERE project = ? AND git_sha_at_handoff = ?
+        ORDER BY created_at_epoch DESC LIMIT 1
+      `).get(project, currentSha);
+      if (anchor) return true;
+    }
+  } catch { /* git/DB failure must not break the rest of the pipeline */ }
+
+  // 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 +217,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 +260,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-llm.mjs

@@ -15,6 +15,11 @@ import {
   RUNTIME_DIR, DEDUP_WINDOW_MS, RELATED_OBS_WINDOW_MS,
   sessionFile, getSessionId, openDb, callLLM, sleep,
 } from './hook-shared.mjs';
+import { EVENT_TYPES, saveEvent } from './lib/activity.mjs';
+
+// T9: memdir-incompatible types live in the `events` table, not `observations`.
+// Set lookup is O(1) — authoritative source is lib/activity.mjs::EVENT_TYPES.
+const EVENT_TYPE_SET = new Set(EVENT_TYPES);
 
 // ─── Save Observation to DB ─────────────────────────────────────────────────
 
@@ -172,6 +177,96 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
   }
 }
 
+// ─── obs → summary shape mapping ────────────────────────────────────────────
+// handleLLMEpisode's internal `obs` uses camelCase/legacy names (lessonLearned,
+// files, filesRead). persistHaikuSummary takes the plan's stable snake_case
+// shape. Keep the mapping here so the dispatcher's public signature stays
+// clean for external callers that already use the plan shape.
+function obsToSummary(obs) {
+  return {
+    type: obs.type,
+    title: obs.title,
+    subtitle: obs.subtitle,
+    narrative: obs.narrative,
+    concepts: obs.concepts,
+    facts: obs.facts,
+    files_modified: obs.files,
+    files_read: obs.filesRead,
+    importance: obs.importance,
+    lesson_learned: obs.lessonLearned,
+    search_aliases: obs.searchAliases,
+  };
+}
+
+// ─── T9: Haiku Summary Dispatcher (events vs observations routing) ──────────
+//
+// Routes memdir-incompatible types (the 8 values in EVENT_TYPES) to the
+// activity `events` table, and keeps legacy/memdir-aligned types (e.g.
+// `change`, which is the only non-event type hook-llm currently emits) on
+// the existing observations path.
+//
+// Input shape (matches the v2.31 MVP plan's stable interface):
+//   summary: { type, title, lesson_learned?, narrative?, importance?, files_modified? }
+//   ctx:     { project, session_id, preSavedObsId? }
+//
+// Returns { table: 'events'|'observations', id: number|null }. Callers inspect
+// `table` to decide whether follow-up observations-only logic (linking, vector
+// refresh) applies.
+//
+// NOTE: The foreground pre-save in hook.mjs:110/336 intentionally still writes
+// to `observations` for immediate visibility. When the background worker
+// processes the episode (handleLLMEpisode), it passes the pre-saved id in
+// `ctx.preSavedObsId`; this dispatcher then deletes the pre-saved observations
+// row and inserts a fresh event for event-typed summaries (upgrade-delete
+// semantics). Observations-typed summaries reuse the pre-saved row directly
+// (caller handles the UPDATE, since it needs the enriched FTS fields).
+export function persistHaikuSummary(db, summary, ctx) {
+  if (EVENT_TYPE_SET.has(summary.type)) {
+    // Upgrade-delete: the foreground pre-save landed in `observations` with a
+    // rule-inferred type; now that Haiku has classified it as an event type,
+    // we must remove the stale observations row before inserting the event.
+    // Atomic via better-sqlite3 transaction: either both succeed or neither.
+    const insertEvent = () => saveEvent(db, {
+      project: ctx.project,
+      event_type: summary.type,
+      title: summary.title,
+      body: summary.lesson_learned || summary.narrative || null,
+      file_paths: (Array.isArray(summary.files_modified) && summary.files_modified.length > 0)
+        ? summary.files_modified
+        : null,
+      importance: summary.importance ?? 1,
+      created_at_epoch: Date.now(),
+    });
+
+    if (ctx.preSavedObsId) {
+      const id = db.transaction(() => {
+        db.prepare(`DELETE FROM observations WHERE id = ?`).run(ctx.preSavedObsId);
+        return insertEvent();
+      })();
+      return { table: 'events', id };
+    }
+
+    return { table: 'events', id: insertEvent() };
+  }
+
+  // Fallthrough: memdir-compatible / legacy types use the observations path.
+  // Map the Haiku/plan field names to saveObservation's expected shape.
+  const id = saveObservation({
+    type: summary.type,
+    title: summary.title,
+    subtitle: summary.subtitle || '',
+    narrative: summary.narrative || '',
+    concepts: summary.concepts || [],
+    facts: summary.facts || [],
+    files: summary.files_modified || [],
+    filesRead: summary.files_read || [],
+    importance: summary.importance ?? 1,
+    lessonLearned: summary.lesson_learned || null,
+    searchAliases: summary.search_aliases || null,
+  }, ctx.project, ctx.session_id, db);
+  return { table: 'observations', id };
+}
+
 // ─── Related Observation Linking ─────────────────────────────────────────────
 
 function linkRelatedObservations(db, savedId, obs, episode) {
@@ -504,46 +599,72 @@ search_aliases: 2-6 alternative search terms someone might use to find this memo
 
   try {
     let savedId;
+    let savedTable;
 
     if (episode.savedId && obs) {
-      // Upgrade pre-saved observation with LLM-enriched data
-      const { conceptsText, factsText, textField } = buildFtsTextField(obs);
-      const minhashSig = computeMinHash((obs.title || '') + ' ' + (obs.narrative || ''));
-      db.prepare(`
-        UPDATE observations SET type=?, title=?, subtitle=?, narrative=?, concepts=?, facts=?,
-          text=?, importance=?, files_read=?, minhash_sig=?, lesson_learned=?, search_aliases=?
-        WHERE id = ?
-      `).run(
-        obs.type, truncate(obs.title, 120), obs.subtitle || '',
-        truncate(obs.narrative || '', 500),
-        conceptsText, factsText, textField,
-        obs.importance,
-        JSON.stringify(obs.filesRead || []),
-        minhashSig,
-        obs.lessonLearned || null,
-        obs.searchAliases || null,
-        episode.savedId
-      );
-      savedId = episode.savedId;
-      debugLog('DEBUG', 'llm-episode', `upgraded pre-saved obs #${savedId}`);
-
-      // Update TF-IDF vector with enriched content
-      try {
-        const vocab = getVocabulary(db);
-        if (vocab) {
-          const vecText = [obs.title || '', obs.narrative || '', conceptsText].filter(Boolean).join(' ');
-          const vec = computeVector(vecText, vocab);
-          if (vec) {
-            db.prepare('INSERT OR REPLACE INTO observation_vectors (observation_id, vector, vocab_version, created_at_epoch) VALUES (?, ?, ?, ?)')
-              .run(savedId, Buffer.from(vec.buffer), vocab.version, Date.now());
+      if (EVENT_TYPE_SET.has(obs.type)) {
+        // Upgrade-delete: pre-saved observation's rule-inferred type was later
+        // classified by Haiku as an event type. Delete the stale observations
+        // row and insert into events instead. Dispatcher handles the atomic
+        // swap via transaction.
+        const result = persistHaikuSummary(db, obsToSummary(obs), {
+          project: episode.project,
+          session_id: episode.sessionId,
+          preSavedObsId: episode.savedId,
+        });
+        savedId = result.id;
+        savedTable = result.table;
+        debugLog('DEBUG', 'llm-episode', `upgrade-delete: obs #${episode.savedId} → event #${savedId}`);
+      } else {
+        // Non-event type (e.g. `change`) — upgrade pre-saved observations row in place
+        // so the enriched FTS text field + minhash + vector are refreshed atomically.
+        const { conceptsText, factsText, textField } = buildFtsTextField(obs);
+        const minhashSig = computeMinHash((obs.title || '') + ' ' + (obs.narrative || ''));
+        db.prepare(`
+          UPDATE observations SET type=?, title=?, subtitle=?, narrative=?, concepts=?, facts=?,
+            text=?, importance=?, files_read=?, minhash_sig=?, lesson_learned=?, search_aliases=?
+          WHERE id = ?
+        `).run(
+          obs.type, truncate(obs.title, 120), obs.subtitle || '',
+          truncate(obs.narrative || '', 500),
+          conceptsText, factsText, textField,
+          obs.importance,
+          JSON.stringify(obs.filesRead || []),
+          minhashSig,
+          obs.lessonLearned || null,
+          obs.searchAliases || null,
+          episode.savedId
+        );
+        savedId = episode.savedId;
+        savedTable = 'observations';
+        debugLog('DEBUG', 'llm-episode', `upgraded pre-saved obs #${savedId}`);
+
+        // Update TF-IDF vector with enriched content
+        try {
+          const vocab = getVocabulary(db);
+          if (vocab) {
+            const vecText = [obs.title || '', obs.narrative || '', conceptsText].filter(Boolean).join(' ');
+            const vec = computeVector(vecText, vocab);
+            if (vec) {
+              db.prepare('INSERT OR REPLACE INTO observation_vectors (observation_id, vector, vocab_version, created_at_epoch) VALUES (?, ?, ?, ?)')
+                .run(savedId, Buffer.from(vec.buffer), vocab.version, Date.now());
+            }
           }
-        }
-      } catch (e) { debugCatch(e, 'handleLLMEpisode-vector'); }
+        } catch (e) { debugCatch(e, 'handleLLMEpisode-vector'); }
+      }
     } else {
-      savedId = saveObservation(obs, episode.project, episode.sessionId, db);
+      // Clean insert (no pre-save) — dispatcher routes by type.
+      const result = persistHaikuSummary(db, obsToSummary(obs), {
+        project: episode.project,
+        session_id: episode.sessionId,
+      });
+      savedId = result.id;
+      savedTable = result.table;
     }
 
-    if (savedId) {
+    // Related-observation linking only applies to rows in `observations` —
+    // the `events` table has its own lifecycle (supersede/accessed_count).
+    if (savedId && savedTable === 'observations') {
       try {
         linkRelatedObservations(db, savedId, obs, episode);
       } catch (e) { debugCatch(e, 'relatedObsLinking'); }

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)
@@ -686,10 +716,29 @@ async function handleSessionStart() {
       } catch (e) { debugCatch(e, 'session-start-exit-fast-summary'); }
     }
 
+    // T10c: Startup dashboard — aggregate git/tasks/plans/handoff/events into a
+    // structured JSON hookSpecificOutput block. Emitted BEFORE the plain-text
+    // <claude-mem-context> so both surfaces coexist. Empty string → skip.
+    try {
+      const { buildDashboard } = await import('./lib/startup-dashboard.mjs');
+      const dashboardText = buildDashboard({ db, project, projectPath: process.cwd() });
+      if (dashboardText) {
+        process.stdout.write(JSON.stringify({
+          suppressOutput: true,
+          hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext: dashboardText,
+          },
+        }) + '\n');
+      }
+    } catch (e) { debugCatch(e, 'session-start-dashboard'); }
+
     // 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 +815,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'); }