claude-mem-lite 2.69.0 → 2.71.0

package/.claude-plugin/marketplace.json

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

package/README.md

@@ -209,14 +209,14 @@ rm -rf ~/claude-mem-lite/   # pre-v0.5 unhidden (if not auto-moved)
 
 ### MCP Tools (used automatically by Claude)
 
-As of v2.34.0, the server registers 17 tools in total but only the 6 **core**
+As of v2.70.0, the server registers 20 tools in total but only the 9 **core**
 tools appear in `tools/list`. The 11 **hidden** tools remain callable at the
 protocol layer (`tools/call` by exact name still routes normally); they're
 omitted from the list response so Claude Code sessions don't load 11 extra
 tool schemas at startup. Hidden tools are the maintenance / admin / browser
 surface — reach them through the CLI column in the second table.
 
-**Core (6, exposed to Claude Code)**
+**Core (9, exposed to Claude Code)**
 
 | Tool | Description |
 |------|-------------|
@@ -225,7 +225,10 @@ surface — reach them through the CLI column in the second table.
 | `mem_recall` | Recall observations related to a file. Use before editing to surface past bugfixes and context. |
 | `mem_timeline` | Browse observations chronologically around an anchor point. |
 | `mem_get` | Retrieve full details for specific observation IDs (includes importance and related_ids). |
-| `mem_save` | Manually save a memory/observation. |
+| `mem_save` | Manually save a memory/observation. Accepts `closes_deferred` array for transactional closure of deferred work. |
+| `mem_defer` | Mark work for a future session (v2.70+). First-class carry-forward signal, surfaced in SessionStart `### Deferred Work` block. |
+| `mem_defer_list` | List open deferred items for the current project. |
+| `mem_defer_drop` | Drop a deferred item without fixing it; requires a `reason` for the audit trail. |
 
 **Hidden-but-callable (11, CLI-routed)**
 

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', 'activity', 'adopt', 'unadopt', 'memdir-audit', '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', 'adopt', 'unadopt', 'memdir-audit', 'defer', 'help']);
 const INSTALL_COMMANDS = new Set(['install', 'uninstall', 'status', 'doctor', 'cleanup', 'cleanup-hooks', 'self-update', 'release']);
 
 const cmd = process.argv[2];

package/hook-context.mjs

@@ -407,26 +407,30 @@ export function buildSessionContextLines(db, project, now = new Date(), currentC
     handoffLines.push('');
   }
 
-  // 5b. Deferred Work — project-level importance≥3 obs that survived prior
-  // session boundaries. Independent of the per-session handoff: even when the
-  // most recent /clear or /exit handoff has stale or meta-only `working_on`,
-  // genuine carry-forward decisions stay surfaced. Capped at 3 to keep the
-  // banner skim-able. Quiet-hooks does NOT suppress: the whole point is
-  // visibility for cross-session continuity.
-  const deferredObs = db.prepare(`
-    SELECT id, type, title FROM observations
-    WHERE project = ? AND COALESCE(compressed_into, 0) = 0
-      AND superseded_at IS NULL
-      AND COALESCE(importance, 1) >= 3
-      AND ${notLowSignalTitleClause('')}
-    ORDER BY created_at_epoch DESC LIMIT 3
+  // 5b. Deferred Work — backed by deferred_work table (v2.70.0).
+  // Replaces the prior importance≥3 obs proxy. Items shown by per-project
+  // ordinal so user can refer to "处理1" / "handle item 1" naturally; D#<id>
+  // is the stable handle for tool-layer references (closes_deferred=[N]).
+  // Quiet-hooks does NOT suppress: cross-session continuity is the whole point.
+  const deferredItems = db.prepare(`
+    SELECT id, title, priority,
+           ROW_NUMBER() OVER (
+             ORDER BY priority DESC, created_at_epoch ASC
+           ) AS ordinal
+    FROM deferred_work
+    WHERE project = ? AND status = 'open'
+    ORDER BY priority DESC, created_at_epoch ASC
+    LIMIT 5
   `).all(project);
 
   const deferredLines = [];
-  if (deferredObs.length > 0) {
+  if (deferredItems.length > 0) {
     deferredLines.push('### Deferred Work');
-    for (const o of deferredObs) {
-      deferredLines.push(`- ${typeIcon(o.type)} [${o.type}] ${truncate(o.title, 140)} (#${o.id})`);
+    for (const d of deferredItems) {
+      const pTag = d.priority === 3 ? '🔴' : d.priority === 1 ? '⚪' : '🟡';
+      deferredLines.push(
+        `${d.ordinal}. ${pTag} [P${d.priority}] ${truncate(d.title, 120)} (D#${d.id})`
+      );
     }
     deferredLines.push('');
   }

package/hook-handoff.mjs

@@ -2,7 +2,8 @@
 // Extracted for testability — hook.mjs has module-level side effects
 
 import { basename } from 'path';
-import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, LOW_SIGNAL_TITLE, EDIT_TOOLS, isMetaTriggerPrompt, notLowSignalTitleClause } from './utils.mjs';
+import { truncate, extractMatchKeywords, tokenizeHandoff, isSpecificTerm, scrubSecrets, LOW_SIGNAL_TITLE, EDIT_TOOLS, isMetaTriggerPrompt, notLowSignalTitleClause } from './utils.mjs';
+import { scrubRecord } from './lib/scrub-record.mjs';
 import {
   HANDOFF_EXPIRY_CLEAR, HANDOFF_EXPIRY_EXIT, HANDOFF_ANCHOR_MAX_AGE,
   HANDOFF_MATCH_THRESHOLD, CONTINUE_KEYWORDS,
@@ -161,6 +162,23 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
   // `scopeSessionId` (CC UUID) tags the row for parallel scoping; falls back to
   // the mem-internal `sessionId` when the caller didn't supply one (tests + legacy).
   const storedSessionId = scopeSessionId || sessionId;
+  // Defense-in-depth: aggregates are built from already-stored rows + raw
+  // session memory; scrub at the persistence boundary regardless of source.
+  // Order matters: scrub raw values BEFORE truncation, so a secret straddling
+  // the truncation boundary doesn't fall below scrubSecrets's regex length
+  // floors. JSON-stringified fields (key_files) are pre-scrubbed at the
+  // element level before stringify — letting scrubSecrets rewrite the JSON
+  // string would risk breaking downstream JSON.parse.
+  const safe = scrubRecord('session_handoffs', {
+    working_on: workingOn,
+    completed: completed.map(c => `[${c.type}] ${c.title}`).join('\n'),
+    unfinished,
+    key_decisions: decisions.map(d => d.title).join('\n'),
+    match_keywords: keywords,
+  });
+  const safeKeyFiles = JSON.stringify(
+    [...fileSet].slice(0, 20).map(f => scrubSecrets(String(f)))
+  );
   db.prepare(`
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -175,12 +193,12 @@ export function buildAndSaveHandoff(db, sessionId, project, type, episodeSnapsho
       git_sha_at_handoff = excluded.git_sha_at_handoff
   `).run(
     project, type, storedSessionId,
-    truncate(workingOn, 1000),
-    completed.map(c => `[${c.type}] ${c.title}`).join('\n'),
-    unfinished.length > 3000 ? unfinished.slice(0, 2999) + '…' : unfinished,
-    JSON.stringify([...fileSet].slice(0, 20)),
-    decisions.map(d => d.title).join('\n'),
-    keywords,
+    truncate(safe.working_on, 1000),
+    safe.completed,
+    safe.unfinished.length > 3000 ? safe.unfinished.slice(0, 2999) + '…' : safe.unfinished,
+    safeKeyFiles,
+    safe.key_decisions,
+    safe.match_keywords,
     Date.now(),
     gitShaAtHandoff,
   );

package/hook-llm.mjs

@@ -10,6 +10,7 @@ import {
   getCurrentBranch, notLowSignalTitleClause,
 } from './utils.mjs';
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
+import { scrubRecord } from './lib/scrub-record.mjs';
 import { getVocabulary, computeVector } from './tfidf.mjs';
 import {
   RUNTIME_DIR, DEDUP_WINDOW_MS, RELATED_OBS_WINDOW_MS,
@@ -194,6 +195,19 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
 
     const { conceptsText, factsText, textField } = buildFtsTextField(obs);
 
+    // Defense-in-depth: scrub text fields before INSERT. Source is LLM output
+    // (Haiku occasionally regurgitates input verbatim — error logs, hashes).
+    const safe = scrubRecord('observations', {
+      text: textField,
+      title: obs.title || '',
+      subtitle: obs.subtitle || '',
+      narrative: obs.narrative || '',
+      concepts: conceptsText,
+      facts: factsText,
+      lesson_learned: obs.lessonLearned || null,
+      search_aliases: obs.searchAliases || null,
+    });
+
     // Atomic: observation INSERT + observation_files + vector in one transaction
     const savedId = db.transaction(() => {
       const result = db.prepare(`
@@ -201,16 +215,16 @@ export function saveObservation(obs, projectOverride, sessionIdOverride, externa
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(
         sessionId, project,
-        textField, obs.type, obs.title, obs.subtitle || '',
-        obs.narrative || '',
-        conceptsText,
-        factsText,
+        safe.text, obs.type, safe.title, safe.subtitle,
+        safe.narrative,
+        safe.concepts,
+        safe.facts,
         JSON.stringify(obs.filesRead || []),
         JSON.stringify(obs.files || []),
         obs.importance ?? 1,
         minhashSig,
-        obs.lessonLearned || null,
-        obs.searchAliases || null,
+        safe.lesson_learned,
+        safe.search_aliases,
         getCurrentBranch(),
         now.toISOString(), now.getTime()
       );
@@ -823,19 +837,32 @@ ${actionList}`;
         // so the enriched FTS text field + minhash + vector are refreshed atomically.
         const { conceptsText, factsText, textField } = buildFtsTextField(obs);
         const minhashSig = computeMinHash((obs.title || '') + ' ' + (obs.narrative || ''));
+        // Scrub LLM-output text fields at the UPDATE boundary, mirroring the
+        // INSERT path. type is an enum, importance is numeric, files_read is a
+        // JSON array (already scrubbed upstream), minhash_sig is hash bytes.
+        const safe = scrubRecord('observations', {
+          title: truncate(obs.title, 120),
+          subtitle: obs.subtitle || '',
+          narrative: truncate(obs.narrative || '', 500),
+          concepts: conceptsText,
+          facts: factsText,
+          text: textField,
+          lesson_learned: obs.lessonLearned || null,
+          search_aliases: obs.searchAliases || null,
+        });
         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.type, safe.title, safe.subtitle,
+          safe.narrative,
+          safe.concepts, safe.facts, safe.text,
           obs.importance,
           JSON.stringify(obs.filesRead || []),
           minhashSig,
-          obs.lessonLearned || null,
-          obs.searchAliases || null,
+          safe.lesson_learned,
+          safe.search_aliases,
           episode.savedId
         );
         savedId = episode.savedId;
@@ -973,6 +1000,23 @@ ${obsList}`;
         // 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: llmParsed.request || '',
+          investigated: llmParsed.investigated || '',
+          learned: llmParsed.learned || '',
+          completed: llmParsed.completed || '',
+          next_steps: llmParsed.next_steps || '',
+          remaining_items: llmParsed.remaining_items || '',
+          lessons: lessonsJson,
+          key_decisions: decisionsJson,
+        });
         db.prepare(`
           UPDATE session_summaries
           SET request = COALESCE(NULLIF(?, ''), request),
@@ -988,23 +1032,33 @@ ${obsList}`;
               created_at_epoch = ?
           WHERE id = ?
         `).run(
-          llmParsed.request || '', llmParsed.investigated || '', llmParsed.learned || '',
-          llmParsed.completed || '', llmParsed.next_steps || '',
-          llmParsed.remaining_items || '',
-          lessonsJson, decisionsJson,
+          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
         );
       } else {
+        const safe = scrubRecord('session_summaries', {
+          request: llmParsed.request || '',
+          investigated: llmParsed.investigated || '',
+          learned: llmParsed.learned || '',
+          completed: llmParsed.completed || '',
+          next_steps: llmParsed.next_steps || '',
+          remaining_items: 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,
-          llmParsed.request || '', llmParsed.investigated || '', llmParsed.learned || '',
-          llmParsed.completed || '', llmParsed.next_steps || '',
-          llmParsed.remaining_items || '',
-          lessonsJson, decisionsJson,
+          safe.request, safe.investigated, safe.learned,
+          safe.completed, safe.next_steps,
+          safe.remaining_items,
+          safe.lessons, safe.key_decisions,
           now.toISOString(), now.getTime()
         );
       }
@@ -1013,3 +1067,25 @@ ${obsList}`;
     db.close();
   }
 }
+
+// Test-only — DO NOT import outside tests/. Underscore prefix is a
+// convention; the plugin has no `main`/`exports` field so external imports
+// are blocked at the package level, but a misguided sibling import inside
+// this repo could drag this into prod by accident. If that ever needs
+// enforcing, move the helper to a tests/_helpers/ module that takes a
+// db-insert callback.
+//
+// Exercises the same scrubRecord path used by saveObservation without
+// spinning up the full LLM dispatcher. Lets the e2e leak test verify that
+// the observations INSERT path scrubs all configured text fields.
+export const __insertObservationForTest = (db, obs) => {
+  const safe = scrubRecord('observations', obs);
+  db.prepare(`INSERT INTO observations (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts, files_read, files_modified, importance, minhash_sig, lesson_learned, search_aliases, branch, created_at, created_at_epoch)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+    obs.session_id, obs.project, safe.text, 'change',
+    safe.title, safe.subtitle, safe.narrative,
+    safe.concepts, safe.facts, obs.files_read, obs.files_modified,
+    obs.importance, obs.minhash_sig, safe.lesson_learned, safe.search_aliases,
+    obs.branch, new Date().toISOString(), Date.now(),
+  );
+};

package/hook-optimize.mjs

@@ -11,6 +11,7 @@ import {
 } from './utils.mjs';
 import { callModelJSON } from './haiku-client.mjs';
 import { acquireLLMSlot, releaseLLMSlot } from './hook-semaphore.mjs';
+import { scrubRecord } from './lib/scrub-record.mjs';
 import { getVocabulary, computeVector, cosineSimilarity } from './tfidf.mjs';
 import { DB_DIR } from './schema.mjs';
 
@@ -159,12 +160,22 @@ search_aliases: 2-6 alternative search terms (include CJK if applicable).`;
       const textField = [conceptsText, factsText, searchAliases || '', bigramText].filter(Boolean).join(' ');
       const minhashSig = computeMinHash((title || '') + ' ' + (narrative || ''));
 
+      // Scrub LLM-output text fields at the UPDATE boundary. type is an
+      // enum, importance is numeric, minhash_sig is hash bytes.
+      const safe = scrubRecord('observations', {
+        title, narrative,
+        concepts: conceptsText,
+        facts: factsText,
+        text: textField,
+        lesson_learned: lessonLearned,
+        search_aliases: searchAliases,
+      });
       db.prepare(`
         UPDATE observations SET type=?, title=?, narrative=?, concepts=?, facts=?,
           text=?, importance=?, lesson_learned=?, search_aliases=?, minhash_sig=?, optimized_at=?
         WHERE id = ?
-      `).run(type, title, narrative, conceptsText, factsText, textField,
-        importance, lessonLearned, searchAliases, minhashSig, Date.now(), cand.id);
+      `).run(type, safe.title, safe.narrative, safe.concepts, safe.facts, safe.text,
+        importance, safe.lesson_learned, safe.search_aliases, minhashSig, Date.now(), cand.id);
 
       rebuildVector(db, cand.id, [title, narrative, conceptsText]);
 
@@ -277,7 +288,14 @@ export function applyNormalization(db, groups) {
       const existingAliases = row.search_aliases || '';
       const originalTerms = terms.filter(t => aliasMap.has(t.toLowerCase()) && aliasMap.get(t.toLowerCase()) !== t);
       const newAliases = [existingAliases, ...originalTerms].filter(Boolean).join(' ');
-      updateStmt.run(uniqueConcepts, newAliases, Date.now(), row.id);
+      // Defense-in-depth scrub. Canonical concept names come from LLM output
+      // (identifySynonymGroups via Sonnet); existing values are already
+      // scrubbed but free LLM tokens can re-introduce secret-shaped strings.
+      const safe = scrubRecord('observations', {
+        concepts: uniqueConcepts,
+        search_aliases: newAliases,
+      });
+      updateStmt.run(safe.concepts, safe.search_aliases, Date.now(), row.id);
       updated++;
     }
   }
@@ -397,13 +415,22 @@ Return ONLY valid JSON:
     const minhashSig = computeMinHash((title || '') + ' ' + (narrative || ''));
     const importance = clampImportance(parsed.importance || 2);
 
+    // Scrub LLM-output cluster-merge text fields at the UPDATE boundary.
+    // importance is numeric; minhash_sig is hash bytes.
+    const safe = scrubRecord('observations', {
+      title, narrative,
+      concepts: conceptsText,
+      facts: factsText,
+      text: textField,
+      lesson_learned: lessonLearned,
+    });
     db.transaction(() => {
       db.prepare(`
         UPDATE observations SET title=?, narrative=?, concepts=?, facts=?, text=?,
           importance=?, lesson_learned=?, minhash_sig=?, optimized_at=?
         WHERE id = ?
-      `).run(title, narrative, conceptsText, factsText, textField,
-        importance, lessonLearned, minhashSig, Date.now(), keeper.id);
+      `).run(safe.title, safe.narrative, safe.concepts, safe.facts, safe.text,
+        importance, safe.lesson_learned, minhashSig, Date.now(), keeper.id);
 
       const otherIds = others.map(o => o.id);
       const ph = otherIds.map(() => '?').join(',');
@@ -573,13 +600,24 @@ JSON: {"title":"descriptive summary ≤120 chars","narrative":"comprehensive sum
         VALUES (?,?,?,?,?,'active')`
       ).run(sessionId, sessionId, project, now.toISOString(), now.getTime());
 
+      // Defense-in-depth: title/narrative/etc. are LLM-generated compression
+      // output; scrub at the persistence boundary regardless of upstream trust.
+      const safe = scrubRecord('observations', {
+        text: textField,
+        title,
+        narrative,
+        concepts: conceptsText,
+        facts: factsText,
+        lesson_learned: lessonLearned,
+        search_aliases: searchAliases,
+      });
       const result = db.prepare(`INSERT INTO observations
         (memory_session_id, project, text, type, title, subtitle, narrative, concepts, facts,
          files_read, files_modified, importance, lesson_learned, search_aliases, optimized_at,
          created_at, created_at_epoch)
         VALUES (?,?,?,?,?,'',?,?,?,'[]','[]',2,?,?,?,?,?)`
-      ).run(sessionId, project, textField, 'discovery', title, narrative,
-        conceptsText, factsText, lessonLearned, searchAliases, Date.now(),
+      ).run(sessionId, project, safe.text, 'discovery', safe.title, safe.narrative,
+        safe.concepts, safe.facts, safe.lesson_learned, safe.search_aliases, Date.now(),
         new Date(medianEpoch).toISOString(), medianEpoch);
 
       const sId = Number(result.lastInsertRowid);

package/hook-precompact.mjs

@@ -0,0 +1,44 @@
+// claude-mem-lite: PreCompact hook handler.
+// Fires immediately before Claude Code auto-compaction begins. Emits a
+// fresh <claude-mem-context> block on stdout so the summarizer that
+// produces the compacted context has the most relevant memory in scope.
+// Differs from SessionStart-on-compact (which fires AFTER compaction):
+// PreCompact ensures memory survives the compaction step itself.
+
+import { buildSessionContextLines } from './hook-context.mjs';
+import { inferProject, debugCatch, debugLog } from './utils.mjs';
+
+/**
+ * Build + emit the memory context block on stdout. Pure read; no DB writes.
+ *
+ * @param {object} ctx
+ * @param {import('better-sqlite3').Database} ctx.db
+ * @param {string} ctx.project
+ * @param {string} [ctx.sessionId]
+ * @returns {void}
+ */
+export function handlePreCompact({ db, project, sessionId }) {
+  try {
+    const body = buildSessionContextLines(db, project, new Date(), sessionId || null);
+    if (!body || String(body).trim() === '') return;
+    process.stdout.write(`<claude-mem-context>\n${body}\n</claude-mem-context>\n`);
+  } catch (e) {
+    debugCatch(e, 'handlePreCompact');
+  }
+}
+
+/**
+ * Default-export entry for hook.mjs dispatcher. Caller passes an opened DB
+ * and the parsed stdin payload — no I/O performed inside this function
+ * beyond what handlePreCompact does.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {object} hookData Parsed JSON from hook stdin
+ * @returns {Promise<void>}
+ */
+export async function entry(db, hookData) {
+  const project = inferProject();
+  const sessionId = hookData?.session_id;
+  debugLog('DEBUG', 'pre-compact', `project=${project} sessionId=${sessionId || 'none'}`);
+  handlePreCompact({ db, project, sessionId });
+}