@pcircle/memesh 2.10.1 → 3.0.0

package/scripts/hooks/post-commit.js

@@ -1,307 +1,169 @@
 #!/usr/bin/env node
 
-/**
- * PostCommit Hook - Auto-save commit context to MeMesh Knowledge Graph
- *
- * Registered as a PostToolUse hook. Detects git commit commands and
- * saves the commit details (message, files changed, diff summary)
- * to the MeMesh knowledge graph for future recall.
- *
- * Commit saving runs silently. Plan progress prints a timeline to stderr.
- */
-
-import {
-  MEMESH_DB_PATH,
-  readStdin,
-  sqliteBatchEntity,
-  getDateString,
-  logError,
-  logMemorySave,
-  queryActivePlans,
-  matchCommitToStep,
-  addObservation,
-  updateEntityMetadata,
-  updateEntityTag,
-  createRelation,
-  renderTimeline,
-} from './hook-utils.js';
-import fs from 'fs';
+import { createRequire } from 'module';
 import { execFileSync } from 'child_process';
-
-// ============================================================================
-// Git Commit Detection
-// ============================================================================
-
-/**
- * Check if a Bash tool call is a git commit
- * @param {Object} toolData - Normalized tool data
- * @returns {boolean}
- */
-function isGitCommit(toolData) {
-  if (toolData.toolName !== 'Bash') return false;
-  if (!toolData.success) return false;
-
-  const cmd = toolData.arguments?.command || '';
-  return /git\s+commit\s/.test(cmd) && !cmd.includes('--amend');
-}
-
-// ============================================================================
-// Git Info Extraction
-// ============================================================================
-
-/**
- * Extract latest commit details using git CLI
- * @returns {{ hash: string, subject: string, body: string, filesChanged: string[], diffStat: string } | null}
- */
-function getLatestCommitInfo() {
-  try {
-    // Get commit hash and message
-    const logOutput = execFileSync('git', [
-      'log', '-1',
-      '--format=%H%n%s%n%b',
-    ], { encoding: 'utf-8', timeout: 5000 }).trim();
-
-    const lines = logOutput.split('\n');
-    const hash = lines[0] || '';
-    const subject = lines[1] || '';
-    const body = lines.slice(2).join('\n').trim();
-
-    // Get files changed
-    const diffNameOnly = execFileSync('git', [
-      'diff-tree', '--no-commit-id', '--name-only', '-r', 'HEAD',
-    ], { encoding: 'utf-8', timeout: 5000 }).trim();
-
-    const filesChanged = diffNameOnly ? diffNameOnly.split('\n').filter(Boolean) : [];
-
-    // Get diff stat (compact summary)
-    const diffStat = execFileSync('git', [
-      'diff-tree', '--no-commit-id', '--stat', 'HEAD',
-    ], { encoding: 'utf-8', timeout: 5000 }).trim();
-
-    return { hash, subject, body, filesChanged, diffStat };
-  } catch (error) {
-    logError('getLatestCommitInfo', error);
-    return null;
-  }
-}
-
-// ============================================================================
-// MeMesh KG Save
-// ============================================================================
-
-/**
- * Save commit context to MeMesh knowledge graph.
- * Uses sqliteBatchEntity for performance (3 spawns instead of 8+).
- * @param {Object} commitInfo - Commit details
- * @returns {boolean} True if saved
- */
-function saveCommitToKG(commitInfo) {
+import { homedir } from 'os';
+import { join, basename } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+
+const require = createRequire(import.meta.url);
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  type TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  metadata JSON
+);
+
+CREATE TABLE IF NOT EXISTS observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_entity_id INTEGER NOT NULL,
+  to_entity_id INTEGER NOT NULL,
+  relation_type TEXT NOT NULL,
+  metadata JSON,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (from_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  FOREIGN KEY (to_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  UNIQUE(from_entity_id, to_entity_id, relation_type)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  tag TEXT NOT NULL,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags_entity ON tags(entity_id);
+CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
+DELETE FROM tags
+WHERE id NOT IN (
+  SELECT MIN(id)
+  FROM tags
+  GROUP BY entity_id, tag
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_entity_tag_unique ON tags(entity_id, tag);
+CREATE INDEX IF NOT EXISTS idx_observations_entity ON observations(entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity_id);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+  name, observations, content='',
+  tokenize='unicode61 remove_diacritics 1'
+);
+`;
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
   try {
-    if (!fs.existsSync(MEMESH_DB_PATH)) {
-      return false;
-    }
-
-    const { hash, subject, body, filesChanged, diffStat } = commitInfo;
-    const shortHash = hash.substring(0, 7);
-    const entityName = `Commit ${shortHash}: ${subject}`;
-
-    // Build observations
-    const observations = [];
-    observations.push(`Commit: ${shortHash} - ${subject}`);
-
-    if (body) {
-      observations.push(`Details: ${body.substring(0, 200)}`);
-    }
-
-    if (filesChanged.length > 0) {
-      const fileList = filesChanged.length <= 10
-        ? filesChanged.join(', ')
-        : `${filesChanged.slice(0, 10).join(', ')} (+${filesChanged.length - 10} more)`;
-      observations.push(`Files changed (${filesChanged.length}): ${fileList}`);
-    }
-
-    // Group files by directory for context
-    if (filesChanged.length > 0) {
-      const dirs = {};
-      filesChanged.forEach(f => {
-        const dir = f.split('/').slice(0, 2).join('/');
-        dirs[dir] = (dirs[dir] || 0) + 1;
-      });
-      const areaSummary = Object.entries(dirs)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([dir, count]) => `${dir} (${count})`)
-        .join(', ');
-      observations.push(`Areas: ${areaSummary}`);
-    }
-
-    if (diffStat) {
-      const statLines = diffStat.split('\n');
-      const summaryLine = statLines[statLines.length - 1]?.trim();
-      if (summaryLine) {
-        observations.push(`Stats: ${summaryLine}`);
+    const data = JSON.parse(input);
+
+    // Only process Bash tool outputs
+    if (data.tool_name !== 'Bash') return exit0();
+    const toolOutput = typeof data.tool_output === 'string'
+      ? data.tool_output
+      : JSON.stringify(data.tool_output || '');
+
+    // Detect git commit in output
+    // Pattern: [branch hash] commit message
+    const commitMatch = toolOutput.match(/\[[\w/.-]+ ([a-f0-9]{7,})\] (.+)/);
+    if (!commitMatch) return exit0();
+
+    const branchMatch = commitMatch[0].match(/^\[([^\s]+)\s/);
+    const branch = branchMatch ? branchMatch[1] : 'unknown';
+
+    const commitHash = commitMatch[1];
+    const commitMsg = commitMatch[2];
+    const projectName = basename(data.cwd || process.cwd());
+
+    // Open database (create dir if needed)
+    const dbPath = process.env.MEMESH_DB_PATH || join(homedir(), '.memesh', 'knowledge-graph.db');
+    const dbDir = process.env.MEMESH_DB_PATH
+      ? join(process.env.MEMESH_DB_PATH, '..')
+      : join(homedir(), '.memesh');
+    if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
+
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    try {
+      db.pragma('journal_mode = WAL');
+      db.pragma('foreign_keys = ON');
+
+      // Ensure schema exists
+      db.exec(SCHEMA_SQL);
+
+      const entityName = `commit-${commitHash}`;
+
+      // Check if this is a new or existing entity
+      const insertResult = db.prepare('INSERT OR IGNORE INTO entities (name, type) VALUES (?, ?)').run(entityName, 'commit');
+      const isNew = insertResult.changes > 0;
+      const entity = db.prepare('SELECT id FROM entities WHERE name = ?').get(entityName);
+      if (entity) {
+        // Capture existing observations for FTS delete (before inserting new one)
+        const prevObs = isNew
+          ? []
+          : db.prepare('SELECT content FROM observations WHERE entity_id = ?').all(entity.id);
+        const prevObsText = isNew ? undefined : prevObs.map(o => o.content).join(' ');
+
+        // Add observations
+        db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)').run(entity.id, commitMsg);
+        db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)').run(entity.id, `Branch: ${branch}`);
+
+        // Add richer diff stats as an observation (backward compatible — failures are silently ignored)
+        try {
+          const stat = execFileSync('git', ['show', '--stat', '--format=', commitHash], {
+            cwd: data.cwd || process.cwd(),
+            encoding: 'utf8',
+            timeout: 5000,
+          }).trim();
+          if (stat) {
+            // Last non-empty line is the summary, e.g. "3 files changed, 45 insertions(+), 12 deletions(-)"
+            const statLines = stat.split('\n').filter(l => l.trim());
+            const summary = statLines[statLines.length - 1]?.trim() || '';
+            if (summary) {
+              db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)').run(entity.id, `Diff stats: ${summary}`);
+            }
+          }
+        } catch {
+          // git show failed — no diff stats recorded, existing behavior unchanged
+        }
+
+        // Add project tag
+        const projectTag = `project:${projectName}`;
+        db.prepare('INSERT OR IGNORE INTO tags (entity_id, tag) VALUES (?, ?)').run(entity.id, projectTag);
+
+        // Update FTS index — delete old entry first if entity existed
+        if (prevObsText !== undefined) {
+          db.prepare("INSERT INTO entities_fts(entities_fts, rowid, name, observations) VALUES('delete', ?, ?, ?)").run(entity.id, entityName, prevObsText);
+        }
+        // Fetch all observations (including the one just added) for the new FTS entry
+        const allObs = db.prepare('SELECT content FROM observations WHERE entity_id = ?').all(entity.id);
+        const allObsText = allObs.map(o => o.content).join(' ');
+        db.prepare('INSERT INTO entities_fts(rowid, name, observations) VALUES(?, ?, ?)').run(entity.id, entityName, allObsText);
       }
+    } finally {
+      db.close();
     }
-
-    // Batch: entity + observations + tags in 2 process spawns (was 8+)
-    const metadata = JSON.stringify({
-      hash: shortHash,
-      fullHash: hash,
-      filesCount: filesChanged.length,
-      source: 'post-commit-hook',
-    });
-
-    const tags = ['commit', 'auto-tracked', `date:${getDateString()}`, 'scope:project'];
-
-    const entityId = sqliteBatchEntity(
-      MEMESH_DB_PATH,
-      { name: entityName, type: 'commit', metadata },
-      observations,
-      tags
-    );
-
-    if (entityId === null) return false;
-
-    logMemorySave(`Commit saved: ${shortHash} - ${subject} (${filesChanged.length} files)`);
-    return true;
-  } catch (error) {
-    logError('saveCommitToKG', error);
-    return false;
+  } catch (err) {
+    // Never crash Claude Code — but leave a trace for debugging
+    try { process.stderr.write(`[memesh post-commit] ${err?.message || err}\n`); } catch {}
   }
-}
+  console.log(JSON.stringify({ suppressOutput: true }));
+  exit0();
+});
 
-// ============================================================================
-// Plan Progress Tracking (Beta)
-// ============================================================================
-
-/**
- * Match commit to active plan steps and update progress.
- * Prints Style B timeline to stderr (visible to user).
- * @param {Object} commitInfo - Commit details from git
- * @param {boolean} commitEntitySaved - Whether commit entity was saved to KG
- */
-function updatePlanProgress(commitInfo, commitEntitySaved = false) {
-  try {
-    const activePlans = queryActivePlans(MEMESH_DB_PATH);
-    if (activePlans.length === 0) return;
-
-    const { hash, subject, filesChanged } = commitInfo;
-    const shortHash = hash.substring(0, 7);
-    const commitEntityName = `Commit ${shortHash}: ${subject}`;
-
-    for (const plan of activePlans) {
-      const stepsDetail = plan.metadata?.stepsDetail;
-      if (!stepsDetail || stepsDetail.length === 0) continue;
-
-      const matchResult = matchCommitToStep(
-        { subject, filesChanged },
-        stepsDetail
-      );
-
-      if (!matchResult) continue;
-
-      const { step: matched, confidence } = matchResult;
-
-      // Update step as completed
-      const updatedSteps = stepsDetail.map(s =>
-        s.number === matched.number
-          ? { ...s, completed: true, commitHash: shortHash, date: getDateString(), confidence }
-          : s
-      );
-      const rawCompleted = updatedSteps.filter(s => s.completed).length;
-      const newCompleted = Math.min(rawCompleted, plan.metadata.totalSteps);
-
-      // Update entity metadata
-      updateEntityMetadata(MEMESH_DB_PATH, plan.name, {
-        ...plan.metadata,
-        completed: newCompleted,
-        stepsDetail: updatedSteps,
-        status: newCompleted >= plan.metadata.totalSteps ? 'completed' : 'active',
-      });
-
-      // Add completion observation
-      addObservation(MEMESH_DB_PATH, plan.name,
-        `\u2705 Step ${matched.number} completed by ${shortHash} (${getDateString()})`
-      );
-
-      // Create relation: commit → plan (only if commit entity exists in KG)
-      if (commitEntitySaved) {
-        createRelation(MEMESH_DB_PATH, commitEntityName, plan.name, 'depends_on');
-      }
-
-      // If all steps completed, swap tag and create lesson_learned
-      if (newCompleted === plan.metadata.totalSteps) {
-        updateEntityTag(MEMESH_DB_PATH, plan.name, 'active', 'completed');
-        addObservation(MEMESH_DB_PATH, plan.name,
-          `\ud83c\udf89 Plan completed on ${getDateString()}`
-        );
-
-        // Auto-create lesson_learned entity for the completed plan
-        const planName = plan.name.replace('Plan: ', '');
-        const completedSteps = updatedSteps.filter(s => s.completed);
-        const lessonObs = [
-          `Plan "${planName}" completed (${plan.metadata.totalSteps} steps)`,
-          `Steps: ${completedSteps.map(s => s.description).join(', ')}`,
-          `Commits: ${completedSteps.filter(s => s.commitHash).map(s => s.commitHash).join(', ')}`,
-        ];
-        sqliteBatchEntity(MEMESH_DB_PATH,
-          { name: `Lesson: ${planName} completed`, type: 'lesson_learned', metadata: '{}' },
-          lessonObs,
-          ['lesson', 'plan-completion', `plan:${planName}`, 'scope:project']
-        );
-      }
-
-      // Print timeline to stderr (visible to user — stdout goes to transcript)
-      const timelinePlan = {
-        ...plan,
-        metadata: { ...plan.metadata, completed: newCompleted, stepsDetail: updatedSteps },
-        _lastCommit: shortHash,
-        _matchConfidence: confidence,
-      };
-      console.error('\n' + renderTimeline(timelinePlan, matched.number) + '\n');
-
-      logMemorySave(`Plan progress: ${plan.name} ${newCompleted}/${plan.metadata.totalSteps}`);
-    }
-  } catch (error) {
-    logError('updatePlanProgress', error);
-  }
-}
-
-// ============================================================================
-// Main
-// ============================================================================
-
-async function postCommit() {
-  try {
-    const input = await readStdin(3000);
-    if (!input || input.trim() === '') {
-      process.exit(0);
-    }
-
-    const rawData = JSON.parse(input);
-    const toolData = {
-      toolName: rawData.tool_name || rawData.toolName || 'unknown',
-      arguments: rawData.tool_input || rawData.arguments || {},
-      success: rawData.success !== false,
-    };
-
-    // Only act on successful git commits
-    if (!isGitCommit(toolData)) {
-      process.exit(0);
-    }
-
-    // Extract commit info and save
-    const commitInfo = getLatestCommitInfo();
-    if (commitInfo) {
-      const saved = saveCommitToKG(commitInfo);
-      updatePlanProgress(commitInfo, saved);
-    }
-
-    process.exit(0);
-  } catch (error) {
-    logError('PostCommit', error);
-    process.exit(0); // Never block Claude Code on hook errors
-  }
+function exit0() {
+  process.exit(0);
 }
-
-postCommit();

package/scripts/hooks/pre-compact.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'module';
+import { homedir } from 'os';
+import { join, basename } from 'path';
+import { existsSync, mkdirSync, readFileSync } from 'fs';
+
+const require = createRequire(import.meta.url);
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  type TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  metadata JSON
+);
+
+CREATE TABLE IF NOT EXISTS observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_entity_id INTEGER NOT NULL,
+  to_entity_id INTEGER NOT NULL,
+  relation_type TEXT NOT NULL,
+  metadata JSON,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (from_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  FOREIGN KEY (to_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  UNIQUE(from_entity_id, to_entity_id, relation_type)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  tag TEXT NOT NULL,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags_entity ON tags(entity_id);
+CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
+DELETE FROM tags
+WHERE id NOT IN (
+  SELECT MIN(id)
+  FROM tags
+  GROUP BY entity_id, tag
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_entity_tag_unique ON tags(entity_id, tag);
+CREATE INDEX IF NOT EXISTS idx_observations_entity ON observations(entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity_id);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+  name, observations, content='',
+  tokenize='unicode61 remove_diacritics 1'
+);
+`;
+
+// Timeout guard: always exit within 10 seconds
+const TIMEOUT_MS = 10000;
+const timeoutHandle = setTimeout(() => {
+  try { process.stderr.write('[memesh pre-compact] Timed out after 10s\n'); } catch {}
+  process.exit(0);
+}, TIMEOUT_MS);
+timeoutHandle.unref();
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    // Opt-out check
+    if (process.env.MEMESH_AUTO_CAPTURE === 'false') {
+      return exit0();
+    }
+
+    const data = JSON.parse(input);
+    const sessionId = data.session_id || 'unknown';
+    const transcriptPath = data.transcript_path || '';
+    const cwd = data.cwd || process.cwd();
+    const reason = data.reason || 'auto';
+    const projectName = basename(cwd);
+
+    // Parse transcript to gather insights
+    let toolCallCount = 0;
+    const editedFiles = new Set();
+
+    if (transcriptPath && existsSync(transcriptPath)) {
+      try {
+        const lines = readFileSync(transcriptPath, 'utf8').split('\n');
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const entry = JSON.parse(line);
+            // Count tool uses from assistant message content blocks
+            if (entry.role === 'assistant' && Array.isArray(entry.content)) {
+              for (const block of entry.content) {
+                if (block.type === 'tool_use') {
+                  toolCallCount++;
+                  // Track file edits
+                  const name = block.name || '';
+                  if (name === 'Edit' || name === 'Write' || name === 'MultiEdit') {
+                    const filePath = block.input?.file_path || block.input?.path || '';
+                    if (filePath) editedFiles.add(basename(filePath));
+                  }
+                }
+              }
+            }
+          } catch {
+            // Skip malformed lines
+          }
+        }
+      } catch {
+        // Transcript read failed — proceed with zero counts
+      }
+    }
+
+    const insightCount = editedFiles.size + (toolCallCount > 0 ? 1 : 0);
+    const entityName = `pre-compact-${sessionId}`;
+
+    // Build observation content
+    const obsLines = [`Compaction reason: ${reason}`, `Tool calls: ${toolCallCount}`];
+    if (editedFiles.size > 0) {
+      obsLines.push(`Files edited: ${Array.from(editedFiles).join(', ')}`);
+    }
+
+    // Open (or create) database
+    const dbPath = process.env.MEMESH_DB_PATH || join(homedir(), '.memesh', 'knowledge-graph.db');
+    const dbDir = process.env.MEMESH_DB_PATH
+      ? join(process.env.MEMESH_DB_PATH, '..')
+      : join(homedir(), '.memesh');
+    if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
+
+    const Database = require('better-sqlite3');
+    const db = new Database(dbPath);
+    try {
+      db.pragma('journal_mode = WAL');
+      db.pragma('foreign_keys = ON');
+      db.exec(SCHEMA_SQL);
+
+      // Upsert entity
+      const insertResult = db.prepare('INSERT OR IGNORE INTO entities (name, type) VALUES (?, ?)').run(entityName, 'session-summary');
+      const isNew = insertResult.changes > 0;
+      const entity = db.prepare('SELECT id FROM entities WHERE name = ?').get(entityName);
+
+      if (entity) {
+        // Capture existing observations for FTS delete
+        const prevObs = isNew
+          ? []
+          : db.prepare('SELECT content FROM observations WHERE entity_id = ?').all(entity.id);
+        const prevObsText = isNew ? undefined : prevObs.map(o => o.content).join(' ');
+
+        // Insert each observation line
+        for (const line of obsLines) {
+          db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)').run(entity.id, line);
+        }
+
+        // Add tags
+        const tags = ['source:auto-capture', 'urgency:pre-compact', `project:${projectName}`];
+        for (const tag of tags) {
+          db.prepare('INSERT OR IGNORE INTO tags (entity_id, tag) VALUES (?, ?)').run(entity.id, tag);
+        }
+
+        // Update FTS
+        if (prevObsText !== undefined) {
+          db.prepare("INSERT INTO entities_fts(entities_fts, rowid, name, observations) VALUES('delete', ?, ?, ?)").run(entity.id, entityName, prevObsText);
+        }
+        const allObs = db.prepare('SELECT content FROM observations WHERE entity_id = ?').all(entity.id);
+        const allObsText = allObs.map(o => o.content).join(' ');
+        db.prepare('INSERT INTO entities_fts(rowid, name, observations) VALUES(?, ?, ?)').run(entity.id, entityName, allObsText);
+      }
+    } finally {
+      db.close();
+    }
+
+    const hookOutput = {
+      hookSpecificOutput: {
+        hookEventName: 'PreCompact',
+        additionalContext: `Saved ${insightCount} insights to MeMesh before compaction`,
+      },
+    };
+    console.log(JSON.stringify(hookOutput));
+  } catch (err) {
+    // Hooks must never crash Claude Code — exit cleanly
+    try { process.stderr.write(`[memesh pre-compact] ${err?.message || err}\n`); } catch {}
+  }
+  exit0();
+});
+
+function exit0() {
+  process.exit(0);
+}